मान लीजिए हमारे पास एक N-एरी ट्री है। हमें इसके नोड्स के मानों का लेवल ऑर्डर ट्रैवर्सल लौटाना है। N-एरी ट्री का इनपुट सीरियलाइजेशन उनके लेवल ऑर्डर ट्रैवर्सल में दर्शाया गया है, जहाँ बच्चों के प्रत्येक समूह को नल मान से अलग किया जाता है। उदाहरण: ट्री [1,null,3,2,4,null,5,6] के लिए आउटपुट [[1],[3,2,

मान लीजिए हमारे पास इंटरवल्स का एक संग्रह है। हमें न्यूनतम संख्या में इंटरवल्स हटाने हैं ताकि शेष इंटरवल्स गैर-ओवरलैपिंग (non-overlapping) हों। उदाहरण: [[1,2],[2,3],[3,4],[1,3]] → आउटपुट 1 ([1,3] हटाएँ)। लालची एल्गोरिदम (अंत समय द्वारा सॉर्ट) n = सरणी का आकार। यदि 0, तो 0 लौटाएँ। count = 1 (पहला

मान लीजिए हमारे पास एक बाइनरी सर्च ट्री (BST) है। हमें एक कुंजी k दी जाती है, जिसे BST से हटाकर अपडेटेड BST लौटाना है। उदाहरण: ट्री [5,3,6,2,4,null,7] से कुंजी 3 हटाने पर ट्री [5,4,6,2,null,null,7] बनता है। BST डिलीशन एल्गोरिदम deleteRoot(root) हेल्पर: रूट नोड को हटाता है। यदि राइट सबट्री नहीं

मान लीजिए दो-आयामी स्थान में कुछ गोलाकार गुब्बारे फैले हैं। प्रत्येक गुब्बारे के लिए क्षैतिज व्यास के प्रारंभ और अंत निर्देशांक दिए गए हैं। एक तीर को x-अक्ष पर किसी बिंदु से लंबवत ऊपर दागा जा सकता है। एक गुब्बारा फट जाता है यदि तीर का x-निर्देशांक गुब्बारे के xstart और xend के बीच हो। हमें सभी गुब्

मान लीजिए हमारे पास धनात्मक और ऋणात्मक पूर्णांकों की एक वृत्ताकार सरणी nums है। यदि इंडेक्स पर संख्या k धनात्मक है, तो k कदम आगे बढ़ें। यदि ऋणात्मक (-k) है, तो k कदम पीछे जाएँ। सरणी वृत्ताकार है। हमें जांचना है कि क्या nums 1 होनी चाहिए और उसी इंडेक्स पर शुरू और खत्म होना चाहिए। उदाहरण: [2,-1,1,2,

मान लीजिए हमारे पास एक ट्री का रूट है। हमें सबसे अधिक बार आने वाला सबट्री योग (subtree sum) ढूंढना है। एक नोड का सबट्री योग उस नोड को रूट मानने वाले सबट्री के सभी नोड मानों का योग है (नोड स्वयं सहित)। यदि टाई हो, तो उच्चतम आवृत्ति वाले सभी मान किसी भी क्रम में लौटाएँ। उदाहरण: ट्री [5,2,-5] के लिए

मान लीजिए हमारे पास एक बाइनरी ट्री है। हमें ट्री की अंतिम पंक्ति (सबसे गहरे लेवल) का सबसे बायाँ मान ढूंढना है। उदाहरण: ट्री [3,5,1,6,2,0,8,null,null,7,4] के लिए अंतिम पंक्ति [7,4] है, इसलिए बॉटम लेफ्ट मान 7 है। DFS + गहराई ट्रैकिंग दो वेरिएबल्स ans और maxLevel (प्रारंभ में -1) रखें। रिकर्सिव sol

मान लीजिए हमारे पास एक बाइनरी ट्री है। हमें ट्री के प्रत्येक लेवल का सबसे बड़ा तत्व ढूंढना है। उदाहरण: ट्री [1,3,2,5,3,null,9] के लिए आउटपुट [1,3,9] होगा (लेवल 0: 1, लेवल 1: max(3,2)=3, लेवल 2: max(5,3,9)=9)। DFS + लेवल ट्रैकिंग एक सरणी ans बनाएँ जहाँ ans[level] उस लेवल का अधिकतम मान स्टोर करे।

मान लीजिए हमारे पास एक पूर्णांक सरणी है जिसके सभी तत्व अद्वितीय हैं। एक अधिकतम बाइनरी ट्री निम्न नियमों से बनता है: रूट सरणी का अधिकतम तत्व होता है। बायाँ सबट्री अधिकतम तत्व के बाएँ भाग से बने सबसरणी का अधिकतम ट्री होता है। दायाँ सबट्री अधिकतम तत्व के दाएँ भाग से बने सबसरणी का अधिकतम ट्री होता है।

मान लीजिए हमारे पास एक बाइनरी ट्री है। हमें ट्री की अधिकतम चौड़ाई ढूंढनी है। एक लेवल की चौड़ाई उस लेवल के सबसे बाएँ और सबसे दाएँ नॉन-नल नोड्स के बीच की दूरी है (बीच के नल नोड्स भी गिने जाते हैं)। उदाहरण: ट्री [1,3,2,5,3,null,9] के लिए अधिकतम चौड़ाई 4 है (अंतिम लेवल [5,3,null,9] की लंबाई 4)। BFS +

मान लीजिए हमारे पास एक बाइनरी ट्री का हेड नोड root है, जहाँ प्रत्येक नोड का मान या तो 0 या 1 है। हमें वही ट्री लौटाना है जहाँ हर वह सबट्री हटा दी गई हो जिसमें 1 नहीं है। उदाहरण: इनपुट ट्री [1,1,0,1,1,0,1,0] के लिए, आउटपुट ट्री में केवल वही नोड्स रहेंगे जिनके सबट्री में कम से कम एक 1 है। पोस्ट-ऑर्

मान लीजिए हमारे पास पूर्णांकों का एक वृत्ताकार सरणी C है जिसे सरणी A द्वारा दर्शाया गया है। हमें C के एक गैर-खाली उपसरणी का अधिकतम संभव योग ढूंढना है। एक उपसरणी में निश्चित बफर A के प्रत्येक तत्व को अधिकतम एक बार शामिल किया जा सकता है। उदाहरण: [1,-2,3,-2] के लिए आउटपुट 3 होगा (उपसरणी [3] का योग 3)

मान लीजिए हमारे पास दो अनुक्रम pushed और popped हैं जिनमें विशिष्ट मान हैं। हमें जांचना है कि क्या ये एक प्रारंभिक खाली स्टैक पर पुश और पॉप ऑपरेशन्स के अनुक्रम का परिणाम हो सकते हैं। उदाहरण: push = [1,2,3,4,5], pop = [4,5,3,2,1] → आउटपुट true। संचालन: push(1), push(2), push(3), push(4), pop()→4, p

मान लीजिए हमारे पास दो बाइनरी ट्री हैं। एक फ्लिप ऑपरेशन में किसी नोड के बाएँ और दाएँ सबट्री को स्वैप करना शामिल है। ट्री X, ट्री Y के फ्लिप-समतुल्य (flip equivalent) है यदि हम X में कुछ फ्लिप ऑपरेशन्स करके Y प्राप्त कर सकते हैं। हमें निर्धारित करना है कि दो दिए गए बाइनरी ट्री (रूट root1 और root2) फ

मान लीजिए हमारे पास एक बाइनरी ट्री है। हमें जांचना है कि क्या यह ट्री एक पूर्ण बाइनरी ट्री (Complete Binary Tree) है या नहीं। लेवल n का एक पूर्ण बाइनरी ट्री में n-1 लेवल पूरी तरह भरे होते हैं, और लेवल n पर सभी नोड्स बाईं ओर से भरे होते हैं। उदाहरण: ट्री [1,2,3,4,5,6] के लिए आउटपुट true (1) होगा, क

मान लीजिए हमारे पास एक सरणी A है, जिस पर हम पैनकेक सॉर्ट तकनीक लागू करेंगे। यहाँ मुख्य प्रतिबंध यह है कि हम केवल एक ऑपरेशन rev(arr, i) का उपयोग कर सकते हैं, जो सरणी के तत्वों को इंडेक्स 0 से i तक उलट देता है। यह विचार सिलेक्शन सॉर्ट जैसा है: हम बार-बार अधिकतम तत्व को अंत में रखते हैं और सरणी का आका

मान लीजिए हमारे पास N नोड्स वाला एक बाइनरी ट्री का रूट है, जहाँ प्रत्येक नोड में node.val संख्या में सिक्के हैं, और कुल N सिक्के हैं। एक चाल में, हम दो आसन्न नोड्स चुन सकते हैं और एक सिक्के को एक नोड से दूसरे नोड में ले जा सकते हैं (चाल पैरेंट से चाइल्ड या चाइल्ड से पैरेंट हो सकती है)। हमें वह चालो

मान लीजिए एक देश है जो ट्रेन यात्रा के लिए प्रसिद्ध है। हमने एक साल पहले ही कुछ ट्रेन यात्राओं की योजना बनाई है। हमारे पास एक सरणी है जिसमें उन दिनों की सूची है जब हम यात्रा करेंगे। प्रत्येक दिन 1 से 365 तक का एक पूर्णांक है। ट्रेन टिकट तीन तरीकों से बेचे जाते हैं: 1-दिन का पास costs[0] डॉलर में;

मान लीजिए हमारे पास क्लोज्ड इंटरवल्स की दो सूचियाँ हैं, जहाँ प्रत्येक सूची में इंटरवल्स परस्पर असंयुक्त (pairwise disjoint) हैं और सॉर्टेड क्रम में हैं। हमें इन दो इंटरवल सूचियों का इंटरसेक्शन (अंतर्व्यापन) निकालना है। हम जानते हैं कि क्लोज्ड इंटरवल [a, b] को a ≤ b के रूप में दर्शाया जाता है, जो उ

मान लीजिए हमारे पास एक अधिकतम ट्री का रूट नोड है: अधिकतम ट्री एक ट्री है जहां प्रत्येक नोड का मान उसके सबट्री में किसी भी अन्य मान से अधिक होता है। मान लीजिए हमारे पास construct() नामक एक विधि है। यह सूची A से एक रूट बना सकती है। construct() विधि इस तरह है: यदि सूची A खाली है, तो null लौटाएं। अन्य