तीन संख्याएं a, b, n दी गई हैं। वास्तविक मान गणना किए बिना a^n और b^n में से बड़ा मान निर्धारित करें। मुख्य अवलोकन: यदि n सम है, तो दोनों के निरपेक्ष मान लें। फिर a और b की तुलना करें। उदाहरण: a=12, b=24, n=5 → b^n बड़ा है। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; void f

दो संख्याएं दी गई हैं, उनका HCF (GCD) यूक्लिड एल्गोरिदम (पुनरावर्ती) द्वारा खोजें। एल्गोरिदम: gcd(a,b) = gcd(a-b, b)b, अन्यथा gcd(a, b-a)। आधार मामला: a==b या कोई शून्य। उदाहरण: 98 और 56 → HCF = 14। C++ कार्यान्वयन b) return gcd(a - b, b); return gcd(a, b - a); } int main() { int a = 98,

आयत की भुजाएं n, m और कट्स की संख्या k दी गई है। ठीक k कट्स (क्षैतिज/लंबवत) लगाकर प्राप्त होने वाले सबसे छोटे टुकड़े के क्षेत्रफल का अधिकतम संभव मान खोजें। n+m-2 तो असंभव। यदि k < max(n,m)-1 तो एक दिशा में कट्स लगाएं। अन्यथा दोनों दिशाओं में। उदाहरण: n=3, m=4, k=1 → अधिकतम न्यूनतम क्षेत्रफल 6। C++

एक संख्या दी गई है। उसके अंकों का योग और अंकों का गुणनफल तब तक करें जब तक एकल अंक न आ जाए। दोनों में से अधिकतम मान वापस करें। अंक योग: डिजिटल रूट फॉर्मूला n%9 (0 के लिए 9)। अंक गुणनफल: पुनरावृत्त गुणनफल। उदाहरण: 631 → योग एकल अंक: 1, गुणनफल एकल अंक: 8 → अधिकतम 8। C++ कार्यान्वयन 9) { if (n

बाइनरी ट्री दिया गया है। प्रत्येक पैरेंट नोड और उसके दोनों बच्चों के मानों का योग निकालें, और ऐसे सभी जोड़ों में अधिकतम मान खोजें। केवल वे नोड्स जिनके दोनों बच्चे मौजूद हैं, उन पर विचार करें। उदाहरण ट्री के लिए अधिकतम योग 91 (16+67+44 या 15+16+17 आदि)। C++ कार्यान्वयन right = newNode(41); cout

सरणी दी गई है। स्थिति i से j पर जंप कर सकते हैं यदि j, i+1 को विभाजित करता है (1-आधारित इंडेक्सिंग)। प्रत्येक स्थिति के लिए अधिकतम योग पथ खोजें। DP: dp[i] = इंडेक्स i तक अधिकतम योग। प्रत्येक i के लिए, i+1 के भाजक j खोजें और dp[j-1] से अधिकतम लें। उदाहरण: {2, 3, 1, 4, 6, 5} → आउटपुट: 2 5 3 9 8 10। C

मैट्रिक्स दी गई है जहां चालें (i+1, j), (i+1, j-1), (i+1, j+1) हो सकती हैं। पहली पंक्ति के किसी सेल से शुरू करके अंतिम पंक्ति के किसी सेल तक अधिकतम योग पथ खोजें। DP: dp[i][j] = सेल (i,j) तक अधिकतम योग। पहली पंक्ति आरंभ करें, फिर नीचे की पंक्तियों के लिए तीनों संभावित पूर्ववर्तियों से अधिकतम लें। उद

अंकों वाली मैट्रिक्स दी गई है। दो व्यक्ति दो कोनों से शुरू होकर एक बार मिलते हैं और अधिकतम अंक एकत्र करते हैं। पथ इस तरह चुनें कि कुल अंक अधिकतम हों। चार DP टेबल: प्रत्येक व्यक्ति के लिए शुरुआत से मिलन बिंदु तक और मिलन बिंदु से अंत तक। सभी संभावित मिलन बिंदुओं के लिए अधिकतम जोड़ देखें। उदाहरण 3x3 म

N अंतराल और अधिकतम रेंज मान Q दिया गया है। एक अंतराल हटाएं ताकि 1 से Q तक कवर किए गए पूर्णांकों की संख्या अधिकतम हो। प्रत्येक बिंदु की कवरेज गिनें। फिर प्रत्येक अंतराल के लिए, उसके द्वारा विशिष्ट रूप से कवर किए गए बिंदु घटाकर शेष कवरेज देखें। उदाहरण: अंतराल {{1,4},{4,5},{5,6},{6,7},{3,5}}, Q=7 → अं

मैट्रिक्स दी गई है जिसमें # अवरुद्ध पथ, * अंक, . अनुमत पथ है। शीर्ष-बाएं से नीचे-दाएं जाएं (दाएं/नीचे चाल) और वापस आएं (बाएं/ऊपर चाल) ताकि अधिकतम अंक एकत्र हों। दो पथ एक साथ सोचें: दोनों (0,0) से (n-1,m-1) तक जाते हैं। DP स्थिति: dp[row1][col1][row2]। उदाहरण 5x5 मैट्रिक्स के लिए अधिकतम अंक 8। C++ क

n वृत्त दिए गए हैं। कोई दो वृत्त संकेंद्रीय नहीं हैं और कोई तीन वृत्त एक बिंदु पर नहीं मिलते, तो अधिकतम प्रतिच्छेदन बिंदुओं की संख्या n*(n-1) होती है (प्रत्येक जोड़ी 2 बिंदुओं पर मिलती है)। उदाहरण: n=3 → 6 प्रतिच्छेदन बिंदु। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; int i

n सीधी रेखाएं दी गई हैं। कोई दो रेखाएं समानांतर नहीं हैं और कोई तीन रेखाएं समवर्ती नहीं हैं, तो अधिकतम प्रतिच्छेदन बिंदुओं की संख्या n*(n-1)/2 होती है। उदाहरण: n=8 → 28 प्रतिच्छेदन बिंदु। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; #define ll long int ll countMaxIntersect(

सरणी दी गई है जिसमें प्रत्येक तत्व अधिकतम दो बार आता है। दो उपसमुच्चय बनाएं जिनमें कोई पुनरावृत्ति न हो और उनके योग का अंतर अधिकतम हो। रणनीति: एकल घटना वाले तत्वों को उनके चिह्न के आधार पर अलग करें। धनात्मक को एक उपसमुच्चय में, ऋणात्मक को दूसरे में। दोहरे तत्वों को अनदेखा करें (वे अंतर में योगदान न

तीन रेखा खंडों के केंद्र और लंबाई दी गई है। प्रत्येक केंद्र को अधिकतम K दूरी तक हिला सकते हैं। प्रतिच्छेदन क्षेत्र की अधिकतम लंबाई खोजें। केंद्रों को सॉर्ट करें। तीन केंद्रों के बीच की दूरी के आधार पर तीन मामले: यदि = 2*k + length: प्रतिच्छेदन 0। यदि = 2*k: प्रतिच्छेदन = 2*k - (center[2] - center[

आकार N की सरणी और पूर्णांक K दिया गया है। ठीक K तत्व हटाएं ताकि परिणामी सरणी का मध्य तत्व अधिकतम हो। अवलोकन: K हटाने के बाद सरणी का आकार N-K होगा। मध्य इंडेक्स (N-K+1)/2 होगा। मूल सरणी में यह इंडेक्स low से high के बीच हो सकता है। इस रेंज में अधिकतम मान खोजें। उदाहरण: N=5, K=2, arr={9,5,3,7,10} → अ

आकार N की सरणी दी गई है। N-1 ऑपरेशंस करें: या तो a[j] = a[i]*a[j] करके a[i] हटाएं, या सिर्फ a[i] हटाएं (केवल एक बार)। शेष मान को अधिकतम करें। रणनीति: नकारात्मक संख्याओं की गिनती, शून्य की गिनती। विषम नकारात्मक होने पर सबसे छोटे निरपेक्ष मान वाले नकारात्मक को हटाएं। शून्य को हटाएं। ऑपरेशंस प्रिंट कर

दो समान आकार की सरणियाँ A और B दी गई हैं। सरणी B में एक विंडो (उपसरणी) ढूंढें जिसका योग अधिकतम हो, शर्त कि सरणी A में उसी विंडो के सभी तत्व अद्वितीय हों। स्लाइडिंग विंडो + हैश सेट का उपयोग करें। उदाहरण: A={0,1,2,3,0,1,4}, B={9,8,1,2,3,4,5} → अधिकतम योग 20। C++ कार्यान्वयन #include <bits/stdc++.h

4 अंक दिए गए हैं। उनसे 24-घंटे प्रारूप (HH:MM) में बनने वाला अधिकतम वैध समय खोजें। लालची दृष्टिकोण: घंटे का दहाई अंक (0-2), इकाई अंक (0-3 यदि दहाई 2 है, अन्यथा 0-9), मिनट का दहाई (0-5), इकाई (0-9)। उदाहरण: {0,0,0,9} → 09:00। C++ कार्यान्वयन #include <bits/stdc++.h> using namespace std; map g

0 और 1 की स्ट्रिंग दी गई है। आप वर्तमान वर्ण के समान वर्ण पर जंप कर सकते हैं। स्ट्रिंग के अंत तक पहुंचने के लिए आवश्यक अधिकतम जंप लंबाई खोजें। रणनीति: अंतिम वर्ण को लक्ष्य मानें। लगातार विपरीत वर्णों की गिनती करें। अधिकतम गिनती + 1 ही उत्तर है। उदाहरण: 1010101 → अधिकतम जंप 2। C++ कार्यान्वयन #inclu

N मीटर की रस्सी को पूर्णांक लंबाई में काटें ताकि टुकड़ों की लंबाई का गुणनफल अधिकतम हो। DP सूत्र: maxProd(n) = max(i * (n-i), i * maxProd(n-i)) सभी i=1 से n-1 के लिए। उदाहरण: N=10 → अधिकतम गुणनफल 36 (3,3,4)। C++ कार्यान्वयन b) ? a : b; } int max(int a, int b, int c) { return max(a, max(b, c)); } i