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

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

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

LongestIncreaingSubsequence सरणी से निरंतर अनुवर्ती का पूर्णांक देता है। विधि में लूप के लिए है, जो पुनरावृति करता है और संख्याओं का ट्रैक रखता है। अंतिम परिणाम में अधिकतम गणना की जाएगी। समय जटिलता ओ (एन) है क्योंकि प्रत्येक तत्व एक बार देखा जाता है और अंतरिक्ष जटिलता ओ (1) है क्योंकि हम किसी भी भंड

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

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

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

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

CoinChangeTopDownApproach 4 पैरामीटर लेता है, n राशि है, सिक्के सरणी में वे सिक्के हैं जिनसे राशि की गणना की जानी है, t सिक्कों की कुल संख्या है, dp सरणी सभी पूर्व परिकलित मान। यदि राशि 0 है तो 0 लौटाएं। यदि मान पहले से ही गणना की गई है तो डीपी सरणी से वापस आएं। यदि मान की गणना नहीं की जाती है तो Co

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

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

पुनरावर्ती दृष्टिकोण में हम एक पेड़ को खोजने के लिए सममित है या नहीं, हम शुरू में जांचते हैं कि पेड़ शून्य है या नहीं, यदि पेड़ शून्य है तो इसका सममित, यदि पेड़ शून्य नहीं है तो हम एमेथोड आइसोसिमेट्रिक मिरर कहते हैं। बाएँ बच्चे और दाएँ बच्चे का मान, यदि बाएँ और दाएँ दोनों बच्चे शून्य हैं, तो हम सममि

बाइनरी सर्च ट्री को उल्टा करने के लिए, हम एक विधि InvertABinarySearchTree कहते हैं जो एक पैरामीटर के रूप में नोड लेता है। यदि नोड शून्य है, तो शून्य वापस आ जाता है, यदि नोड शून्य नहीं है, तो हम बाएं और दाएं बच्चे के मूल्यों को पारित करके इनवर्टबाइनरीसर्च ट्री को पुनरावर्ती रूप से कॉल करते हैं। और बा

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

HasPathsum 2 पैरामीटर लेता है एक ट्री नोड है और दूसरा योग मान है, शुरू में हम जांचते हैं कि नोड शून्य है या नहीं, यदि नोड शून्य है तो हम झूठी वापसी करते हैं। यदि नोड शून्य नहीं है तो हम HasPathSum पुनरावर्ती विधि कहते हैं, प्रत्येक पुनरावर्ती चरण में हम नोड मान से योग मान घटाते रहते हैं। यदि योग का

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

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

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

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

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