स्ट्रिंग बैलेंस है अगर हर ( के लिए दो कंसेक्यूटिव )) हों। मिनिमम इंसर्शन्स (ओपनिंग/क्लोजिंग) काउंट करें। एल्गोरिदम o = अनमैच्ड ओपनिंग काउंट, ret = इंसर्शन्स काउंट। स्ट्रिंग स्कैन करें: ( मिले तो o++। ) मिले: अगर अगला भी ) है तो पेयर प्रोसेस करें (o-- या ret++ अगर o=0)। सिंगल ) मिले: ret++ और o-- या

रिकर्सिव नियम S₁=0, Sᵢ=Sᵢ₋₁ + 1 + reverse(invert(Sᵢ₋₁)) से बाइनरी स्ट्रिंग बनाकर K-वां बिट ढूंढें। एल्गोरिदम अगर k=1 तो 0 रिटर्न। दो ऐरे arr (0 से शुरू) और arr2 (1 से शुरू) मेंटेन करें। जब तक len(arr): दोनों ऐरे एक्सपैंड करें: arr = arr + [1] + arr2, arr2 = arr + [0] + arr2। arr[k-1] रिटर्न करें।

प्रीफिक्स सम और सेट का उपयोग करके टारगेट सम वाले नॉन-ओवरलैपिंग सबअर्रे की मैक्सिमम संख्या ढूंढें (ग्रीडी)। एल्गोरिदम t सेट में प्रीफिक्स सम स्टोर करें (शुरू में {0})। temp = करंट प्रीफिक्स सम। प्रत्येक एलिमेंट के लिए: temp += i, prev = temp - target। अगर prev in t: सबअर्रे मिला, ans++, t = {temp} र

ऐरे arr[i] = 2i+1 से शुरू करके, एक ऑपरेशन में एक एलिमेंट से 1 घटाकर दूसरे में 1 जोड़ें। सभी एलिमेंट्स बराबर करने के लिए मिन ऑपरेशन्स। एल्गोरिदम टारगेट वैल्यू = n (क्योंकि sum = n², प्रत्येक एलिमेंट = n)। पहले आधे एलिमेंट्स (जो n से छोटे हैं) को n तक लाने के लिए आवश्यक ऑपरेशन्स जोड़ें। फॉर्मूला: Σ(n

डायरेक्टेड एसाइक्लिक ग्राफ (DAG) में जिन वर्टेक्सेज़ का इन-डिग्री 0 है, उनसे सभी नोड्स पहुंचे जा सकते हैं। एल्गोरिदम सभी नोड्स का सेट बनाएं (0 से n-1)। सभी एजेज़ के डेस्टिनेशन नोड्स (v) का सेट बनाएं। सोर्स नोड्स = सभी नोड्स - डेस्टिनेशन नोड्स (यानी इन-डिग्री 0 वाले)। यही मिनिमम वर्टेक्स सेट है। उद

ऑपरेशन: (0) इंडेक्स पर +1, (1) पूरे ऐरे को ×2। जीरो ऐरे से टारगेट ऐरे बनाने के लिए मिनिमम ऑपरेशन्स ढूंढें। एल्गोरिदम प्रत्येक नंबर के लिए: बाइनरी रिप्रेजेंटेशन में 1s की संख्या = इन्क्रीमेंट ऑपरेशन्स। सबसे लंबी बाइनरी लंबाई - 1 = डबल ऑपरेशन्स (सभी एलिमेंट्स पर एक साथ)। टोटल = Σइन्क्रीमेंट्स + मैक्स

3n पाइल्स में से प्रत्येक टर्न में 3 पाइल्स चुनें: प्लेयर2 मैक्स लेता है, प्लेयर1 सेकंड मैक्स, प्लेयर3 मिन। प्लेयर1 के मैक्स कॉइन्स ढूंढें। एल्गोरिदम पाइल्स को सॉर्ट करें। जब तक पाइल्स खाली नहीं: सेकंड लास्ट एलिमेंट (प्लेयर1 का पिक) आंसर में जोड़ें। सेकंड लास्ट, लास्ट, और फर्स्ट एलिमेंट डिलीट करें

परम्यूटेशन ऐरे के अनुसार बिट्स सेट करते हुए, साइज़ M के 1s के कंटीज्युअस ग्रुप का लेटेस्ट स्टेप ढूंढें। एल्गोरिदम l और r ऐरे: प्रत्येक पोजीशन के लिए बाएं/दाएं कंटीज्युअस 1s की लंबाई। प्रत्येक स्टेप पर करंट बिट सेट करें, पड़ोसियों से लंबाई मर्ज करें। num = साइज़ M के ग्रुप्स की संख्या ट्रैक करें। अग

लेवल ऑर्डर ट्रैवर्सल (BFS) से दिए गए नोड के उसी लेवल पर दाएं पड़ोसी नोड को ढूंढें। एल्गोरिदम क्यू से BFS, लेवल दर लेवल प्रोसेस करें। प्रत्येक लेवल के नोड्स को temp लिस्ट में स्टोर करें। अगर टारगेट नोड u मिले तो उसका इंडेक्स नोट करें। अगर इंडेक्स अंतिम है तो None रिटर्न (दाएं कोई नहीं)। अन्यथा temp[

दोनों ट्रीज़ के लीफ नोड्स (ऑपरेंड्स) की फ्रीक्वेंसी काउंट करके तुलना करें: अगर समान तो ट्रीज़ इक्विवेलेंट हैं। एल्गोरिदम DFS से प्रत्येक ट्री के लीफ नोड्स (ऑपरेंड्स) की फ्रीक्वेंसी Counter में गिनें। दोनों काउंटर्स तुलना करें: dic1 == dic2। ऑपरेटर्स को इग्नोर करें, केवल ऑपरेंड्स मैटर करते हैं (कम्य

पोस्टफिक्स एक्सप्रेशन से स्टैक-आधारित एल्गोरिदम से एक्सप्रेशन ट्री बनाएं और रिकर्सिवली मूल्यांकन करें। एल्गोरिदम buildTree(postfix): स्टैक में (नोड, साइड) टपल्स रखें। पोस्टफिक्स से पॉप करके ट्री बनाएं। evaluate(root): अगर नोड न्यूमेरिक तो वैल्यू रिटर्न। वरना लेफ्ट/राइट रिकर्सिवली मूल्यांकन करके ऑपर

पावर के अनुसार सॉर्टेड लिंक्ड लिस्ट पॉलीनोमियल्स को मर्ज-जैसे एल्गोरिदम से जोड़ें: समान पावर के कोएफिशिएंट्स जोड़ें। एल्गोरिदम डमी नोड और करंट नोड इनिशियलाइज़ करें। जब तक दोनों लिस्ट्स खाली नहीं: पावर कंपेयर करें। poly2.power: poly1 नोड अटैच करें। poly1.power < poly2.power: poly2 नोड अटैच करें। सम

बाइनरी ट्री में दो नोड्स का LCA ढूंढने के लिए रिकर्सिव DFS: अगर दोनों सबट्रीज़ में नोड्स मिलें तो वर्तमान नोड LCA है। एल्गोरिदम रिकर्सिव dfs(node) फंक्शन। अगर नोड x या y है: लेफ्ट/राइट चेक करें, कोई मिला तो वर्तमान नोड LCA। लेफ्ट और राइट दोनों से रिकर्सिव कॉल। अगर दोनों नॉन-None रिटर्न करें: वर्तमा

पैरेंट पॉइंटर्स होने पर, एक नोड के सभी एंसेस्टर्स को सेट में स्टोर करके दूसरे नोड के एंसेस्टर्स चेक करें। एल्गोरिदम path_p_r लिस्ट में x के सभी एंसेस्टर्स (रूट तक) स्टोर करें। y से ऊपर जाते हुए चेक करें: अगर y path_p_r में है, तो वही LCA है। नहीं मिला तो y = y.parent जारी रखें। उदाहरण कोड LCA = 5

BFS से एरोनियस राइट चाइल्ड पॉइंटर (सेम लेवल पर पॉइंट करता हुआ) ढूंढें और उस नोड को उसके डिसेंडेंट्स सहित डिलीट करें (टारगेट नोड छोड़कर)। एल्गोरिदम क्यू से BFS ट्रैवर्सल (collections.deque)। parent (पैरेंट, is_left)। visited सेट से डुप्लिकेट विजिट डिटेक्ट करें (एरोनियस लिंक)। जब डुप्लिकेट मिले: ग्रै

लीफ नोड को नया रूट बनाने के लिए पैरेंट पॉइंटर्स का उपयोग करके ट्री को रीस्ट्रक्चर करें: लेफ्ट चाइल्ड राइट बन जाता है, पैरेंट लेफ्ट बन जाता है। एल्गोरिदम रिकर्सिव हेल्पर helper(node, new_par)। अगर नोड मूल रूट है: पैरेंट सेट करें, लेफ्ट/राइट चाइल्ड जो new_par हैं उन्हें None करें। अगर लेफ्ट चाइल्ड है

बाइनरी ट्री में दिए गए नोड्स के लोएस्ट कॉमन एंसेस्टर (LCA) को रिकर्सिव DFS से ढूंढें। एल्गोरिदम रिकर्सिव फंक्शन fn(node) जो नोड या None रिटर्न करता है। अगर नोड टारगेट नोड्स सेट में है, तो नोड रिटर्न करें। लेफ्ट और राइट सबट्री पर रिकर्स करें। अगर दोनों नॉन-None रिटर्न करें, तो वर्तमान नोड LCA है। अन

डायनामिक प्रोग्रामिंग से ऐसा सबसे लंबा सम-लंबाई पैलिंड्रोमिक सबसीक्वेंस ढूंढें जिसमें मध्य को छोड़कर लगातार समान कैरेक्टर्स न हों। एल्गोरिदम n = स्ट्रिंग लंबाई। dp = n×n 2D ऐरे जहां प्रत्येक सेल एक पेयर (length, char) स्टोर करता है। बॉटम-अप DP: i = n-1 से 0, j = i+1 से n-1 तक। अगर s[i] == s[j] और d

Pandas DataFrame को पिवट करके एक ही प्लॉट पर एकाधिक लाइन्स (अलग-अलग इक्वेशन्स) ड्रॉ करें। चरण फिगर साइज़ और ऑटोलेआउट सेट करें। कॉलम equation, x, y वाला DataFrame बनाएं। df.pivot(index=x, columns=equation, values=y) से रीशेप करें। df.plot() से सभी लाइन्स एक साथ प्लॉट करें। plt.show() से दिखाएं। उदा

कॉम्प्लेक्स नंबर्स के रियल और इमैजिनरी पार्ट्स को अलग करके 2D स्कैटर प्लॉट बनाएं (आर्गैंड डायग्राम)। चरण फिगर साइज़ और ऑटोलेआउट सेट करें। रैंडम कॉम्प्लेक्स नंबर्स जनरेट करें: np.random.rand(10) + 1j*np.random.rand(10)। fig, ax = plt.subplots() बनाएं। ax.scatter(data.real, data.imag, c=data.real, cm