मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें इसे इन-प्लेस (in-place) एक सिंगली लिंक्ड लिस्ट में बदलना है। उदाहरण के लिए, दिए गए ट्री के लिए आउटपुट एक सॉर्टेड लिंक्ड लिस्ट होगी। समाधान दृष्टिकोण (रिवर्स इनऑर्डर ट्रैवर्सल) prev := NULL सेट करें। एक रिकर्सिव फ़ंक्शन solve() परिभाषित करें जो रूट लेता

मान लीजिए हमारे पास एक 2D मैट्रिक्स है जिसमें तीन अलग-अलग मान हैं: 2 (दुश्मन), 1 (दीवार), और 0 (खाली सेल)। हमें एक बम का उपयोग करके अधिकतम दुश्मनों को मारने की संख्या ज्ञात करनी है। बम लगाए गए बिंदु से उसी पंक्ति और कॉलम में सभी दुश्मनों को मार देता है जब तक कि दीवार न आ जाए। और हम बम केवल खाली स्था

मान लीजिए हमारे पास दो मान घंटे (hours) और मिनट (minutes) हैं। हमें घंटे और मिनट की सुई के बीच बने छोटे कोण को ज्ञात करना है। उदाहरण के लिए, यदि इनपुट hour = 12, minutes = 45 है, तो आउटपुट 112.5 होगा। समाधान दृष्टिकोण यदि h = 12, तो h := 0 सेट करें। यदि m = 60, तो m := 0 सेट करें। घंटे की सुई का क

मान लीजिए हमारे पास एक 2D बाइनरी मैट्रिक्स है जहां 1 एक कम्युनिकेशन टावर को दर्शाता है, और 0 एक खाली सेल को दर्शाता है। टावर निम्न तरीकों से संवाद कर सकते हैं: यदि टावर A और टावर B एक ही पंक्ति या कॉलम पर हैं, तो वे एक-दूसरे से संवाद कर सकते हैं। यदि टावर A, टावर B से बात कर सकता है और B, C से बात

मान लीजिए हमारे पास लोअरकेस अक्षरों की एक स्ट्रिंग है और हमारे पास लागतों की एक सूची भी है जिसे costs कहा जाता है। स्ट्रिंग और सूची की लंबाई समान होती है। हम कैरेक्टर s[i] को costs[i] लागत पर हटा सकते हैं, और फिर दोनों s[i] और costs[i] हट जाते हैं। हमें सभी लगातार दोहराए जाने वाले कैरेक्टर्स को हटान

मान लीजिए हमारे पास एक संख्या n है, हमें n! (n फैक्टोरियल) में ट्रेलिंग जीरो (अंत में आने वाले शून्य) की संख्या ज्ञात करनी है। उदाहरण के लिए, यदि इनपुट n = 20 है, तो आउटपुट 4 होगा, क्योंकि 20! = 2432902008176640000 समाधान दृष्टिकोण ट्रेलिंग जीरो की संख्या 10 के गुणनखंडों की संख्या पर निर्भर करती है,

मान लीजिए हमारे पास पूर्णांकों की एक सरणी A है; हमें दो नॉन-ओवरलैपिंग (गैर-अतिव्यापी) सबएरे के तत्वों का अधिकतम योग ज्ञात करना है। इन सबएरे की लंबाई L और M है। अधिक सटीक रूप से, हमें सबसे बड़ा V ढूंढना है जिसके लिए: V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) और या तो: 0

मान लीजिए हम एक अनंत संख्या रेखा पर विचार कर रहे हैं, जहां i-वें स्टोन की स्थिति सरणी stones द्वारा दी गई है। एक स्टोन एक एंडपॉइंट स्टोन है यदि उसकी स्थिति सबसे छोटी या सबसे बड़ी है। प्रत्येक चाल में, हम एक एंडपॉइंट स्टोन को उठाते हैं और उसे एक खाली स्थान पर ले जाते हैं ताकि वह अब एंडपॉइंट स्टोन न र

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

मान लीजिए हमारे पास एक ग्रिड है, जहां प्रत्येक सेल में तीन मानों में से एक हो सकता है: 0 - खाली सेल 1 - ताजा संतरा 2 - सड़ा हुआ संतरा हर मिनट, कोई भी ताजा संतरा जो किसी सड़े हुए संतरे के निकट (ऊपर, नीचे, बाएं, दाएं) होता है, वह सड़ जाता है। हमें न्यूनतम मिनटों की संख्या ज्ञात करनी है जिसके बाद कोई

मान लीजिए हमारे पास एक तस्वीर है जिसमें काले और सफेद पिक्सेल हैं। हमें उन काले पिक्सेल की संख्या ज्ञात करनी है जो पंक्ति R और कॉलम C पर मौजूद हैं और निम्नलिखित नियमों का पालन करते हैं: पंक्ति R और कॉलम C में ठीक N काले पिक्सेल होंगे। वे सभी पंक्तियाँ जिनमें कॉलम C पर काला पिक्सेल है, वे पंक्ति R के

मान लीजिए हमारे पास एक स्ट्रिंग है जिसमें पैरेंथेसिस और पूर्णांक हैं। हमें उस स्ट्रिंग से एक बाइनरी ट्री का निर्माण करना है। पूरा इनपुट एक बाइनरी ट्री को दर्शाता है। इसमें एक पूर्णांक होता है जिसके बाद शून्य, एक या दो जोड़े पैरेंथेसिस होते हैं। पूर्णांक रूट का मान दर्शाता है और पैरेंथेसिस का एक जोड़

मान लीजिए हमारे पास n टीमें हैं और हम हमेशा मजबूत टीम को कमजोर टीम के साथ खेलने की व्यवस्था करते हैं, जैसे रैंक 1 टीम को रैंक n टीम के साथ खेलने के लिए, यह रणनीति प्रतियोगिता को अधिक रोचक बनाने के लिए है। अब हमें उनके अंतिम प्रतियोगिता मैचों को एक स्ट्रिंग के रूप में ढूंढना है। ये टीमें 1 से n तक क

मान लीजिए हमारे पास एक बाइनरी ट्री है, हमें इसके सीमा के मानों को रूट से शुरू करके वामावर्त दिशा में ढूंढना है। यहां सीमा में बायां सीमा, पत्ते, और दायां सीमा क्रम में बिना डुप्लिकेट नोड्स के शामिल हैं। बायां सीमा रूट से बाएं-सबसे नोड तक का पथ है। दायां सीमा रूट से दाएं-सबसे नोड तक का पथ है। जब रू

मान लीजिए हमारे पास n पूर्णांकों वाली एक सरणी है, हमें यह ढूंढना है कि क्या ट्रिपलेट्स (i, j, k) हैं जो इन शर्तों का पालन करते हैं: 0 < i, i + 1 < j, j + 1 < k < n - 1 उपसरणियों (0, i - 1), (i + 1, j - 1), (j + 1, k - 1) और (k + 1, n - 1) का योग समान होगा। उपसरणी (L, R) मूल सरणी का एक टुकड़ा है ज

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

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

मान लीजिए हमारे पास एक बाइनरी मैट्रिक्स M है, हमें उस मैट्रिक्स में लगातार एक की सबसे लंबी रेखा ढूंढनी है। रेखा क्षैतिज, लंबवत, विकर्ण या प्रतिविकर्ण हो सकती है। उदाहरण के लिए, यदि इनपुट मैट्रिक्स है: 0110 0110 0001 तो आउटपुट 3 होगा। हल करने की विधि हम डायनामिक प्रोग्रामिंग का उपयोग करेंगे: re

एक पेड़, एक गिलहरी, और कई नट्स हैं। स्थितियों को 2D ग्रिड में सेल द्वारा दर्शाया जाता है। आपका लक्ष्य गिलहरी के लिए सभी नट्स को इकट्ठा करके उन्हें एक-एक करके पेड़ के नीचे रखने के लिए न्यूनतम दूरी ढूंढना है। गिलहरी एक समय में अधिकतम एक नट ले जा सकती है और चार दिशाओं में आगे बढ़ सकती है - ऊपर, नीचे,

मान लीजिए हमारे पास n प्रोसेस हैं, यहां प्रत्येक प्रोसेस की एक अद्वितीय आईडी होती है जिसे PID या प्रोसेस आईडी कहा जाता है और इसका PPID (पैरेंट प्रोसेस आईडी) भी होता है। प्रत्येक प्रोसेस का केवल एक पैरेंट प्रोसेस होता है, लेकिन उसके एक या अधिक चाइल्ड प्रोसेस हो सकते हैं। यह एक ट्री संरचना की तरह है।