MoveZeros नामक एक विधि बनाएं, ऐरे को पार करें और ऐरे में शून्यों की संख्या गिनें। गिनती के आकार के आधार पर अंतिम सेल को शून्य बनाएं। यदि ऐरे की लंबाई नल या खाली है तो प्रोसेसिंग के बिना लौटें। अंतिम परिणाम nums ऐरे में होगा। समय जटिलता O(N) है क्योंकि हम ऐरे को एक बार पार करते हैं।समय जटिलता −

दो स्ट्रिंग्स, X और Y, आइसोमोर्फिक कहलाते हैं यदि X में प्रत्येक वर्ण की सभी घटनाओं को Y प्राप्त करने के लिए किसी अन्य वर्ण से बदला जा सकता है और इसके विपरीत। उदाहरण के लिए, स्ट्रिंग्स ACAB और XCXY पर विचार करें। वर्णों के क्रम को बनाए रखते हुए किसी वर्ण की सभी घटनाओं को किसी अन्य वर्ण से बदला जाना

दिए गए स्ट्रिंग इनपुट से, दो पॉइंटर्स i और j रखकर स्लाइडिंग विंडो तकनीक का उपयोग करें। दोनों i और j स्ट्रिंग में एक ही वर्ण पर इंगित करेंगे। स्ट्रिंग को पार करें और इसे सूची में जोड़ें। यदि दोहराया गया वर्ण मिलता है तो इसे सूची से हटा दें अन्यथा सूची में जोड़ें।उदाहरण 1इनपुट − s = "a

LongestIncreasingSubsequence ऐरे से निरंतर उपअनुक्रम का पूर्णांक लौटाता है। विधि में एक फॉर लूप होता है, जो पुनरावृति करता है और संख्याओं पर नज़र रखता है। अंतिम परिणाम में गणना किया गया अधिकतम होगा। समय जटिलता O(N) है क्योंकि प्रत्येक तत्व को एक बार देखा जाता है और स्पेस जटिलता O(1) है क्योंकि हम कि

फाइबोनैचि अनुक्रम संख्याओं का एक समूह है जो एक या शून्य से शुरू होता है, उसके बाद एक आता है, और इस नियम के आधार पर आगे बढ़ता है कि प्रत्येक संख्या (जिसे फाइबोनैचि संख्या कहा जाता है) पिछली दो संख्याओं के योग के बराबर होती है। टॉप-डाउन दृष्टिकोण एक बड़ी समस्या को छोटे और समझने योग्य टुकड़ों में तोड़न

फाइबोनैचि अनुक्रम संख्याओं का एक समूह है जो एक या शून्य से शुरू होता है, उसके बाद एक आता है, और इस नियम के आधार पर आगे बढ़ता है कि प्रत्येक संख्या (जिसे फाइबोनैचि संख्या कहा जाता है) पिछली दो संख्याओं के योग के बराबर होती है। बॉटम-अप दृष्टिकोण पहले मौलिक स्तर पर छोटी समस्याओं को हल करने पर ध्यान कें

MinimumStepstoOneTopdownApproach पूर्णांक n और एक पूर्णांक ऐरे को इनपुट के रूप में लेता है। पैरामीटर n में तत्वों की कुल संख्या होती है। प्रारंभिक स्थिति जांचती है कि क्या n 1 के बराबर है। यदि n 1 के बराबर है तो 0 लौटाएं। op1, op2 और op3 को अधिकतम मान पर आरंभ करें। यदि n mod 3 0 के बराबर है तो Minim

MinimumStepstoOneBottomdownApproach पूर्णांक n को इनपुट के रूप में लेता है। पैरामीटर n में तत्वों की कुल संख्या होती है। प्रारंभिक स्थिति जांचती है कि क्या n 1 के बराबर है। यदि n 1 के बराबर है तो 0 लौटाएं। op1, op2 और op3 को अधिकतम मान पर आरंभ करें। यदि n mod 3 0 के बराबर है तो MinimumStepstoOneBott

CoinChangeTopDownApproach चार पैरामीटर लेता है: n राशि है, coins ऐरे में वे सिक्के होते हैं जिनसे राशि की गणना की जानी है, t सिक्कों की कुल संख्या है, dp ऐरे सभी पूर्व-गणना किए गए मानों को संग्रहीत करेगा। यदि राशि 0 है तो 0 लौटाएं। यदि मान पहले से गणना किया गया है तो dp ऐरे से लौटाएं। यदि मान गणना न

CoinChangeBottomUpApproach तीन पैरामीटर इनपुट के रूप में लेता है: n राशि है, coins ऐरे में सिक्कों की कुल संख्या होती है, t में सिक्कों की कुल संख्या होती है। एक डायनामिक ऐरे घोषित करें जो पहले से गणना किए गए मानों को संग्रहीत करता है। ऐरे के माध्यम से लूप करें और राशि की गणना के लिए आवश्यक न्यूनतम

इटरेटिव दृष्टिकोण में हमें 2 क्यू बनाने होंगे, एक क्यू लेफ्ट चाइल्ड को सेव करता है और दूसरी क्यू राइट चाइल्ड मान को सेव करती है। यदि ट्री खाली है, तो यह अपने रूट नोड से गुजरने वाली ऊर्ध्वाधर धुरी के प्रति सममित है। अन्यथा, जांचें कि दोनों सबट्री के रूट नोड पर मान समान है या नहीं। यदि है, तो जांचें

रिकर्सिव दृष्टिकोण में ट्री सममित है या नहीं यह जानने के लिए हम प्रारंभ में जांचते हैं कि ट्री null है या नहीं, यदि ट्री null है तो यह सममित है, यदि ट्री null नहीं है तो हम issymmetricmirror मेथड को कॉल करते हैं। isSymmetricMirror में हमें लेफ्ट चाइल्ड और राइट चाइल्ड का मान मिलता है, यदि दोनों लेफ्

बाइनरी सर्च ट्री को इनवर्ट करने के लिए, हम InvertABinarySearchTree मेथड को कॉल करते हैं जो नोड को पैरामीटर के रूप में लेता है। यदि नोड null है तो null लौटाएं, यदि नोड null नहीं है, तो हम लेफ्ट और राइट चाइल्ड मान पास करके InvertABinarySearchTree को रिकर्सिवली कॉल करते हैं। और राइट चाइल्ड मान को लेफ्

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

HasPathSum दो पैरामीटर लेता है: एक ट्री नोड और दूसरा योग मान। प्रारंभ में हम जांचते हैं कि नोड null है या नहीं, यदि नोड null है तो हम false लौटाते हैं। यदि नोड null नहीं है तो हम HasPathSum रिकर्सिव मेथड को कॉल करते हैं, प्रत्येक रिकर्सिव चरण में हम नोड मान से योग मान घटाते रहते हैं। यदि योग का मान

हमें तीन पॉइंटर्स लेने की आवश्यकता है, लो, मिड, हाई। हम लो और मिड पॉइंटर्स को शुरुआत में उपयोग करेंगे, और हाई पॉइंटर दिए गए ऐरे के अंत पर इंगित करेगा। यदि ऐरे [मिड] = 0, तो ऐरे [मिड] को ऐरे [लो] के साथ स्वैप करें और दोनों पॉइंटर्स को एक बार बढ़ाएं। यदि ऐरे [मिड] = 1, तो कोई स्वैपिंग आवश्यक नहीं है।

दो पॉइंटर्स लें, लो, हाई। हम लो पॉइंटर्स को शुरुआत में उपयोग करेंगे, और हाई पॉइंटर दिए गए ऐरे के अंत पर इंगित करेगा। यदि ऐरे [लो] = 0, तो कोई स्वैपिंग आवश्यक नहीं है। यदि ऐरे [लो] = 1, तो स्वैपिंग आवश्यक है। हाई पॉइंटर को एक बार डिक्रीमेंट करें। समय जटिलता - O(N) उदाहरण using System; namespace Cons

एक ऐरे और संख्या k दी गई है, समस्या बताती है कि हमें ऐरे को k बार घुमाना है। यदि दी गई संख्या 3 है तो ऐरे को 3 बार घुमाया जाना चाहिए। एक रिवर्स फ़ंक्शन बनाएं जो ऐरे, स्टार्ट और एंड को पैरामीटर के रूप में लेता है। पहले चरण में 0 से ऐरे लंबाई तक रिवर्स मेथड कॉल करें। दूसरे चरण में 0 से k-1 तक रिवर्स

ऐरे पहले से सॉर्टेड है, हम दो पॉइंटर्स ii और jj रख सकते हैं, जहां ii धीमा-धावक है जबकि jj तेज-धावक है। जब तक nums[i] = nums[j], हम jj को बढ़ाकर डुप्लिकेट को छोड़ देते हैं। जब हमें nums[j] != nums[i] मिलता है तो डुप्लिकेट रन समाप्त हो गया है इसलिए हमें इसका मान nums[i + 1] पर कॉपी करना होगा। ii को फ

ऐरे पहले से सॉर्टेड है, हम दो पॉइंटर्स ii और jj रख सकते हैं, जहां ii धीमा-धावक है जबकि jj तेज-धावक है। जब तक nums[i] = nums[j], हम jj को बढ़ाकर डुप्लिकेट को छोड़ देते हैं। जब हमें nums[j] != nums[i] मिलता है तो डुप्लिकेट रन समाप्त हो गया है इसलिए हमें इसका मान nums[i + 1] पर कॉपी करना होगा। ii को फ