स्ट्रिंग्स की सूची genes दी गई है जहां प्रत्येक स्ट्रिंग समान लंबाई की है और केवल A, C, G, T वर्णों से बनी है। दो स्ट्रिंग्स एक ही म्यूटेशन समूह में हैं यदि वे केवल एक वर्ण में भिन्न हैं। यह संबंध संक्रामक है। कुल म्यूटेशन समूहों की संख्या ज्ञात करें। उदाहरण: [ACGT, ACGC, ACTT, TTTT, TGTT] → 2 समूह

एक बाइनरी ट्री ऊंचाई-संतुलित (height-balanced) होता है यदि प्रत्येक नोड के लिए उसके बाएं और दाएं सबट्री की ऊंचाई का निरपेक्ष अंतर 0 या 1 हो। दिए गए ट्री के लिए आउटपुट true (1) है। समाधान दृष्टिकोण (पोस्ट-ऑर्डर DFS) एक ग्लोबल फ्लैग ret = true रखें। dfs(node) फंक्शन नोड की ऊंचाई वापस करता है: यदि न

एक संख्या n दी गई है, उसके बाइनरी प्रतिनिधित्व में लगातार 1 की सबसे लंबी श्रृंखला की लंबाई ज्ञात करें। उदाहरण: n = 312 → बाइनरी 100111000 → सबसे लंबी लगातार 1 की श्रृंखला 3 है। एल्गोरिदम ret = 0, len = 0 आरंभ करें। 32 बिट्स के लिए लूप (i = 0 से 31): यदि i-वां बिट सेट है ( i) & 1), तो len++। अन्यथ

बाइनरी ट्री को बाएं से देखने पर जो नोड्स दिखाई देते हैं, उन्हें लेफ्ट साइड व्यू कहते हैं। उदाहरण ट्री के लिए आउटपुट [1, 2, 5] है। समाधान दृष्टिकोण (DFS) हम प्री-ऑर्डर DFS का उपयोग करते हैं जहां हम पहले बाएं सबट्री को एक्सप्लोर करते हैं: एक सरणी ret और वेरिएबल lvl = -1 रखें। dfs(node, level) फंक्शन

बाइनरी ट्री का लेवल ऑर्डर ट्रैवर्सल (BFS) करने का प्रोग्राम। इसमें हम स्तर दर स्तर नोड्स को विजिट करते हैं। उदाहरण ट्री के लिए ट्रैवर्सल क्रम: [1, 2, 3, 5, 4]। एल्गोरिदम एक क्यू बनाएं और रूट डालें। जब तक क्यू खाली नहीं: सामने का नोड निकालें, उसका मान प्रिंट/संग्रहीत करें। बाएं बच्चे को क्यू में ड

एक बाइनरी ट्री दिया गया है जहां रूट का स्तर 1 है। हमें वह सबसे छोटा स्तर X ढूंढना है जहां सभी नोड्स के मानों का योग न्यूनतम हो। उदाहरण ट्री में रूट 5 है, बाएं 4, दाएं -10, आदि। स्तर 2 का योग 4 + (-10) = -6 है, जो न्यूनतम है, इसलिए आउटपुट 2 है। समाधान दृष्टिकोण हम लेवल ऑर्डर ट्रैवर्सल (BFS) का उपयोग

हमें एक संख्या सूची nums और एक पूर्णांक k दिया गया है। जांचना है कि क्या सूची को ऐसी उपसूचियों में विभाजित किया जा सकता है जहां प्रत्येक उपसूची में ठीक k तत्व हों और वे लगातार बढ़ते क्रम में हों। उदाहरण: nums = [4, 3, 2, 4, 5, 6], k = 3 → आउटपुट true, क्योंकि हम [2, 3, 4] और [4, 5, 6] बना सकते हैं।

एक अनुक्रम को बिटोनिक कहा जाता है यदि यह पहले सख्ती से बढ़ता है और फिर सख्ती से घटता है। एक पूर्णतः बढ़ता या घटता अनुक्रम भी बिटोनिक माना जाता है। उदाहरण के लिए, सरणी [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15] के लिए सबसे लंबे बिटोनिक उपअनुक्रम की लंबाई 7 है। समाधान दृष्टिकोण हम दो सरणि

मान लीजिए हमारे पास दो स्ट्रिंग्स text1 और text2 हैं, हमें उनके सबसे लंबे सामान्य उपअनुक्रम (Longest Common Subsequence - LCS) की लंबाई ज्ञात करनी है। एक उपअनुक्रम वह स्ट्रिंग है जो मूल स्ट्रिंग से कुछ वर्णों को हटाकर (बिना क्रम बदले) बनती है। उदाहरण के लिए, abe abcde का उपअनुक्रम है लेकिन adc नहीं

मान लीजिए हमारे पास दो लोअरकेस स्ट्रिंग्स X और Y हैं, हमें उनके सबसे लंबे सामान्य उपस्ट्रिंग की लंबाई ज्ञात करनी है। उदाहरण के लिए, यदि इनपुट X = helloworld और Y = worldbook है, तो आउटपुट 5 होगा, क्योंकि world सबसे लंबा सामान्य उपस्ट्रिंग है और इसकी लंबाई 5 है। समाधान दृष्टिकोण इस समस्या को हल करने

मान लीजिए हमारे पास दो बाइनरी ट्री हैं और जब हम उनमें से एक को दूसरे पर रखते हैं, तो कुछ नोड्स ओवरलैप होते हैं जबकि अन्य नहीं। हमें उन्हें एक नए बाइनरी ट्री में मर्ज करना है। मर्ज नियम यह है कि यदि दो नोड्स ओवरलैप करते हैं, तो उनके मानों को जोड़कर मर्ज किए गए नोड का नया मान बनाया जाता है। अन्यथा, ग

मान लीजिए हमारे पास एक धनात्मक संख्या n है, हमें उन पूर्ण वर्ग संख्याओं की न्यूनतम संख्या ढूंढनी है जिनका योग n के समान हो। इसलिए यदि संख्या 10 है, तो आउटपुट 2 है, क्योंकि संख्याएं 10 = 9 + 1 हैं। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - डायनामिक प्रोग्रामिंग के लिए एक टेबल बनाएं, लंबाई n +

मान लीजिए हमारे पास एक पोस्टफिक्स अभिव्यक्ति है और हमें इसका मान निकालना है। पोस्टफिक्स अभिव्यक्ति को रिवर्स पोलिश नोटेशन भी कहा जाता है। यहां हमें पोस्टफिक्स अभिव्यक्तियों को हल करने के लिए स्टैक डेटा संरचना का उपयोग करना होगा। इसलिए यदि अभिव्यक्ति 21+3* है, तो उत्तर 9 होगा। आइए चरण देखें - पोस्टफ

मान लीजिए हमारे पास अंतराल का एक सेट है; हमें उन न्यूनतम अंतरालों की संख्या ढूंढनी है जिन्हें हटाया जाना चाहिए ताकि बाकी अंतराल गैर-ओवरलैपिंग हों। इसलिए यदि अंतराल [[8,10],[3,5],[6,9]] हैं, तो आउटपुट 1 होगा, क्योंकि हमें [6,9] को हटाना होगा ताकि बाकी सभी गैर-ओवरलैपिंग हों। इसे हल करने के लिए, हम इन

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है और एक अन्य संख्या k है, हम सूची से अधिकतम एक बार कोई सबलिस्ट हटा सकते हैं। हमें परिणामी सबसे लंबी सूची की लंबाई ढूंढनी है जैसे कि k से सख्ती से कम संख्याओं की मात्रा और k से सख्ती से बड़ी संख्याओं की मात्रा समान हो। इसलिए, यदि इनपुट nums = [6, 10,

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

NULL] होगा। आइए चरण देखें - यदि लिस्ट खाली है, तो null लौटाएं len := 1 tail नामक एक नोड बनाएं := head जब तक tail का next null नहीं है len को 1 से बढ़ाएं tail := tail का next tail का next := head k := k mod len newHead := null i := 0 से len - k तक tail := tail का next newHead := tail का next tail

मान लीजिए हमारे पास एक इनपुट स्ट्रिंग वाक्य है जहां प्रत्येक तत्व एकल वर्ण के रूप में संग्रहीत है, हमें स्ट्रिंग्स को शब्द दर शब्द उल्टा करना है। इसलिए, यदि इनपुट [t,h,e, ,m,a,n, ,i,s, ,n,l,c,e] जैसा है, तो आउटपुट [n,i,c,e, ,i,s, ,m,a,n, ,t,h,e] होगा। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

मान लीजिए हमारे पास दो संख्याएं स्ट्रिंग के रूप में हैं। हमें उन्हें गुणा करना है और परिणाम को भी स्ट्रिंग में लौटाना है। इसलिए यदि संख्याएं 28 और 25 हैं, तो परिणाम 700 होगा। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - दो आर्गुमेंट x और y लेना जो दर्शाता है x, y को विभाजित करता है यदि x < -Inf

मान लीजिए हमारे पास दो स्ट्रिंग्स S और T हैं। हमें जांचना है कि क्या S, T की उपअनुक्रम है या नहीं। इसलिए, यदि इनपुट S = abc, T = adbrcyxd जैसा है, तो आउटपुट True होगा। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - यदि s, t के समान है, तो - true लौटाएं n := s का आकार, m := t का आकार j := 0 i :=