मान लीजिए हमारे पास समान लंबाई की दो स्ट्रिंग्स s और t हैं, और दोनों लोअरकेस अक्षरों में हैं। पहले हम s को किसी भी क्रम में पुनर्व्यवस्थित करते हैं, फिर s को t में बदलने के लिए आवश्यक न्यूनतम परिवर्तनों की संख्या गिनते हैं। उदाहरण के लिए, यदि इनपुट है s = eccynue, t = science, तो आउटपुट 2 होगा। यद

मान लीजिए हमारे पास दो स्ट्रिंग्स s और t हैं। हमें जांचना है कि क्या s, t का रोटेशन है या नहीं, यानी क्या s को घुमाकर t प्राप्त किया जा सकता है? उदाहरण के लिए, यदि इनपुट है s = helloworld और t = worldhello, तो आउटपुट True होगा। समाधान दृष्टिकोण इस समस्या को हल करने के लिए हम निम्नलिखित चरणों का प

स्ट्रिंग दी गई है। लगातार डुप्लिकेट वर्णों को हटाकर केवल एक प्रति रखें। क्रम वही रहे। उदाहरण: heeeeelllllllloooooo → helo। सरल एल्गोरिदम: परिणाम स्ट्रिंग बनाएं, प्रत्येक वर्ण के लिए यदि यह परिणाम के अंतिम वर्ण से अलग है तो जोड़ें। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std;

बाइनरी ट्री दिया गया है। उन नोड्स की गिनती करें जिनका मान उनके सभी वंशजों के मानों से बड़ा या बराबर हो। पोस्ट-ऑर्डर DFS: प्रत्येक नोड अपने सबट्री का अधिकतम मान वापस करता है। यदि नोड का मान ≥ max(बाएं_अधिकतम, दाएं_अधिकतम) तो गिनती बढ़ाएं। उदाहरण ट्री के लिए आउटपुट 4 (नोड 3 को छोड़कर सभी)। C++ कार्या

दो बाइनरी ट्री source और target दिए गए हैं। जांचें कि क्या source का कोई उल्टा रूप (inversion) target का उपट्री है। उल्टा रूप का अर्थ: बाएं और दाएं बच्चे वैकल्पिक रूप से स्वैप हो सकते हैं। रिकर्सिव जांच: दो ट्री उल्टे हैं यदि (बाएं-बाएं और दाएं-दाएं मेल खाते हैं) या (बाएं-दाएं और दाएं-बाएं मेल खाते

सिंगली लिंक्ड लिस्ट दी गई है जिसमें धनात्मक संख्याएं हैं। प्रत्येक नोड का next पॉइंटर उसके मान के बराबर आगे के नोड को इंगित करे। यदि ऐसा नोड नहीं है तो null। उदाहरण: [2,2,3,5,9,15,3,4] → इंडेक्स 0 (मान 2) → इंडेक्स 2 (मान 3) → इंडेक्स 5 (मान 15) → आउटपुट [2, 3, 15]। C++ कार्यान्वयन #include <bit

केवल ( और ) वाली स्ट्रिंग दी गई है। इसे संतुलित करने के लिए न्यूनतम ब्रैकेट जोड़ें। एल्गोरिदम: काउंटर o0 तो o-- अन्यथा cnt++ (बंद ब्रैकेट की जरूरत)। अंत में cnt + o वापस करें। उदाहरण: (()))( → 2 ब्रैकेट चाहिए (बना सकते हैं ((()))())। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace st

अंतरालों की सूची दी गई है [start, end]। दो असंयोगी (non-overlapping) अंतराल चुनें जिनके आकार (end-start+1) का योग न्यूनतम हो। अंत समय के अनुसार सॉर्ट करें। DP + बाइनरी सर्च: प्रत्येक अंतराल के लिए, उससे पहले खत्म होने वाले न्यूनतम आकार वाले अंतराल को बाइनरी सर्च द्वारा खोजें। उदाहरण: {{2,5},{9,10},

संख्याओं की सूची और पूर्णांक k दिया गया है। सूची को बाएं k स्थानों पर घुमाएं। उदाहरण: [5,4,7,8,5,6,8,7,9,2], k=2 → [8,5,6,8,7,9,2,5,4,7] (नोट: उदाहरण में k=3 का उपयोग किया गया है)। सरल दृष्टिकोण: k = k % n। नई सरणी में पहले k से अंत तक, फिर 0 से k-1 तक कॉपी करें। C++ कार्यान्वयन #include <bits/s

लोअरकेस स्ट्रिंग s दी गई है। न्यूनतम लंबाई (कम से कम 2) का उपस्ट्रिंग ढूंढें जिसमें कोई वर्ण अन्य सभी वर्णों के योग से अधिक बार आता हो। ऐसा न होने पर -1 वापस करें। मुख्य अवलोकन: उत्तर केवल 2 या 3 हो सकता है। लंबाई 2: दो समान आसन्न वर्ण (जैसे aa)। लंबाई 3: पैटर्न aba। उदाहरण: abbbcde → bb लंबाई 2 →

मूलधन, दर, और समय दिया गया है। चक्रवृद्धि ब्याज की गणना करें: CI = P * (1 + r/100)^t। उदाहरण: P=10000, r=10.25%, t=5 वर्ष → CI = 16288.9। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; int main() { double principle = 10000, rate = 10.25, time = 5; double CI = principle

दो सरणियाँ X और Y दी गई हैं। उनके बीच पियर्सन सहसंबंध गुणांक खोजें: r = (nΣXY - ΣXΣY) / √[(nΣX² - (ΣX)²)(nΣY² - (ΣY)²)] मान -1 से 1 के बीच होता है। 1 के निकट = मजबूत धनात्मक सहसंबंध। उदाहरण: X={15,18,21,24,27}, Y={25,25,27,31,32} → r ≈ 0.953। C++ कार्यान्वयन #include <bits/stdc++.h> using nam

रेंज [a, b] दी गई है। उन संख्याओं की गिनती करें जिनके भाजकों की संख्या विषम हो। केवल पूर्ण वर्ग संख्याओं के भाजक विषम संख्या में होते हैं। इसलिए रेंज में पूर्ण वर्गों की गिनती करें। सरल कार्यान्वयन: प्रत्येक संख्या के भाजक गिनें (O(n√n))। उदाहरण: रेंज 1 से 10 → 3 संख्याएं (1, 4, 9)। C++ कार्यान्वयन

दो यादृच्छिक चर सेट दिए गए हैं। उनका सहप्रसरण ज्ञात करें: Cov(X,Y) = Σ(xi - meanX)(yi - meanY) / (n-1)। उदाहरण: दो सरणियों के लिए सहप्रसरण -0.0580511। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; float mean(float arr[], int n) { float sum = 0; for (int i = 0; i < n;

कलन संख्या का सूत्र: C_n = 2^n * n + 1। nवीं कलन संख्या खोजें। बिट शिफ्ट का उपयोग करें: 1 << n = 2^n। उदाहरण: n=2 → 2^2 * 2 + 1 = 9। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; unsigned get_cullen(unsigned n) { return (1 << n) * n + 1; } int main() { int n = 2;

तीन बिंदु (x1,y1,z1), (x2,y2,z2), (x3,y3,z3) दिए गए हैं। उनसे गुजरने वाले तल का समीकरण ax + by + cz + d = 0 खोजें। दिशा सदिश: a1=x2-x1, b1=y2-y1, c1=z2-z1 और a2=x3-x1, b2=y3-y1, c2=z3-z1। सामान्य सदिश = क्रॉस गुणनफल। उदाहरण: बिंदु (-1,2,1), (0,-3,2), (1,1,-4) → तल: 26x + 7y + 9z + 3 = 0। C++ कार्या

इकैनोबिफ संख्याएं फिबोनाची जैसी हैं, लेकिन अगली संख्या पिछले दो संख्याओं के अंकों को उल्टा करके जोड़ने से प्राप्त होती है। अनुक्रम: 0, 1, 1, 2, 3, 5, 8, 13, 39 (31+8), 124 (93+31), 514 (421+93), 836 (415+421), ... उदाहरण: N=12 → पहली 12 संख्याएं प्रिंट करें। C++ कार्यान्वयन 0) { rev_num =

दो फ्लोटिंग पॉइंट संख्याओं का GCD खोजें। यूक्लिड एल्गोरिदम को फ्लोट के लिए अनुकूलित करें: gcd(a,b) = gcd(b, a - floor(a/b)*b)। समाप्ति शर्त: |b| < 0.001। उदाहरण: 1.20 और 22.5 → GCD = 0.3। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; double gcd(double a, double b) { if (a

मिडिल स्कूल प्रक्रिया (अभाज्य गुणनखंड) द्वारा GCD खोजें: दोनों संख्याओं का अभाज्य गुणनखंड करें, सामान्य गुणनखंडों को उनके न्यूनतम घात के साथ गुणा करें। उदाहरण: 10 और 15 → अभाज्य गुणनखंड: 10=2×5, 15=3×5 → GCD = 5। C++ कार्यान्वयन exponent[0] = 1; for (i = 2; i size = k - 1; } void DisplayFactor

दो संख्याओं का GCD/HCF यूक्लिड एल्गोरिदम (मॉड्यूलो संस्करण) द्वारा खोजें। एल्गोरिदम: gcd(a,b) = gcd(b, a%b)। यह घटाव संस्करण से तेज है। उदाहरण: 98 और 56 → GCD = 14। C++ कार्यान्वयन b) return gcd(a - b, b); return gcd(a, b - a); } int main() { int a = 98, b = 56; cout << GCD of << a <