हमें एक सरणी arr[] दी गई है जिसमें एक बाइनरी ट्री का इनऑर्डर ट्रैवर्सल है। लक्ष्य उस सरणी से एक स्पेशल बाइनरी ट्री बनाना है। एक स्पेशल बाइनरी ट्री वह है जिसमें रूट नोड का वजन इसके बाएं और दाएं दोनों चाइल्ड के वजन से अधिक होता है। उदाहरण के लिए इनपुट int arr[] = {10, 20, 28, 40, 32, 31, 30} आउटपुट दि

हमें एक बाइनरी ट्री इनपुट के रूप में दिया गया है। लक्ष्य उसमें मौजूद बाइनरी सर्च ट्री (BST) सबट्री की संख्या ज्ञात करना है। BST एक बाइनरी ट्री है जिसमें बायां चाइल्ड रूट से कम और दायां चाइल्ड रूट से अधिक होता है। उदाहरण के लिए इनपुट मानों को इनपुट करने के बाद जो ट्री बनेगा वह नीचे दिया गया है: आउटप

दो ट्रैवर्सल सबसे पहले मूल ऐरे और ऐरे से खोजे और हटाए जाने वाले एलिमेंट को परिभाषित करते हैं: int ele = 5; int arr = [1,2,3,4]; अब हम दिए गए एलिमेंट को खोजने के लिए ऐरे में लूप चलाते हैं: for (i=0; i<length; i++) if (arr[i] == ele) break; यदि दिए गए एलिमेंट की पोजीशन मिल जाती है तो हम उन एलिमेंट्

सबसे पहले मूल ऐरे और ऐरे एलिमेंट्स को हटाने के लिए एक्सक्लूसिव रेंज को परिभाषित करते हैं और मूल ऐरे की लंबाई भी ज्ञात करते हैं: int arr[] = { 2,4,6,8,10,12,14,16,18,20}; int L = 2, R = 6; int length = sizeof(arr) / sizeof(arr[0]); अब हम ऐरे में लूप चलाते हैं और यदि इंडेक्स पोजीशन (i) L से कम या बराब

सबसे पहले उस स्ट्रक्चर को परिभाषित करते हैं जो एक ट्री नोड को दर्शाता है जिसमें डेटा और इसके बाएं और दाएं चाइल्ड नोड होते हैं। यदि यह पहला नोड है जिसे बनाया जा रहा है तो यह रूट नोड है अन्यथा चाइल्ड नोड। struct Node { int data; struct Node *leftChild, *rightChild; }; इसके बाद हम newNode(int data) फ़ं

सबसे पहले उस स्ट्रक्चर को परिभाषित करते हैं जो एक ट्री नोड को दर्शाता है जिसमें डेटा और इसके बाएं और दाएं चाइल्ड नोड होते हैं। यदि यह पहला नोड है जिसे बनाया जा रहा है तो यह रूट नोड है अन्यथा चाइल्ड नोड। struct Node { int data; struct Node *leftChild, *rightChild; }; इसके बाद हम newNode(int data) फ़ं

सबसे पहले हम अपना लिंक्ड लिस्ट परिभाषित करते हैं जिसमें डेटा और अगले नोड का पॉइंटर होता है। struct Node { int data; struct Node* next; }; इसके बाद हम createNode(int data) फ़ंक्शन बनाते हैं जो int data को पैरामीटर के रूप में लेता है और पैरामीटर मान निर्दिष्ट करने के बाद नया बना नोड लौटाता है। नोड का

सबसे पहले हम अपना लिंक्ड लिस्ट परिभाषित करते हैं जिसमें डेटा और अगले नोड का पॉइंटर होता है। struct Node { int data; struct Node* next; }; फिर हम createList(Node ** headPtr, int new_data) फ़ंक्शन बनाते हैं जो Node के डबल पॉइंटर और एक int मान लेता है। फ़ंक्शन के अंदर हम नए बने नोड के नेक्स्ट पॉइंटर को

सबसे पहले हम एक क्लास का उपयोग करके अपना बाइनरी ट्री परिभाषित करते हैं जिसमें int data, btree_node * rightChild, btree_node * leftChild होते हैं। leftChild और rightChild btree_node के पॉइंटर हैं। हमारे क्लास के सभी सदस्य पब्लिक हैं। class btree_node { public: int data; btree_node* leftChild; btree_n

सबसे पहले हम अपनी प्रारंभिक स्ट्रिंग घोषित करते हैं और इसकी लंबाई की गणना करके deleteSubstr(str, length) फ़ंक्शन को पास करते हैं। string str = 01010110011; int length = str.length(); cout <<Count of substring deletion<< deleteSubstr(str, length); deleteSubstr(string str, int length) फ़ंक

डेम्लो संख्याएँ वे पलिंड्रोमिक संख्याएँ हैं जो 11...1 रूप की संख्या के वर्ग से उत्पन्न होती हैं, बशर्ते वह संख्या 10 अंकों से कम हो। सबसे पहले स्ट्रिंग वेरिएबल घोषित करते हैं: string demNum = 1111; string square = ; अब हम demNum स्ट्रिंग की लंबाई तक लूप चलाते हैं। लूप के अंदर हम इंडेक्स मान i को स्ट

एक नियमित सप्तभुज (7 भुजाओं वाला बहुभुज) के विकर्ण की लंबाई ज्ञात करने के लिए हम सूत्र 2 * भुजा * sin(900/14) का उपयोग करते हैं। sin(900/14) का मान लगभग 0.9 होता है। उदाहरण आइए निम्नलिखित कार्यान्वयन को देखें जिससे भुजा से नियमित सप्तभुज का विकर्ण प्राप्त होता है: #include <iostream> using nam

डिलीशन को हटाए गए नोड को सबसे नीचे और सबसे दाएं नोड से बदलकर किया जाता है। आइए पहले उस स्ट्रक्ट को परिभाषित करें जो एक ट्री नोड को दर्शाता है जिसमें डेटा और इसके बाएं और दाएं चाइल्ड नोड होते हैं। यदि यह बनाया जाने वाला पहला नोड है तो यह रूट नोड है अन्यथा चाइल्ड नोड। struct Node { int data;

बाइनरी ट्री का घनत्व इसके आकार को इसकी ऊंचाई से विभाजित करके गणना किया जाता है। बाइनरी ट्री घनत्व = आकार/ऊंचाई। आइए पहले उस स्ट्रक्ट को परिभाषित करें जो एक ट्री नोड को दर्शाता है जिसमें डेटा और इसके बाएं और दाएं चाइल्ड नोड होते हैं। यदि यह बनाया जाने वाला पहला नोड है तो यह रूट नोड है अन्यथा चाइल्ड

आइए पहले उस स्ट्रक्ट को परिभाषित करें जो एक ट्री नोड को दर्शाता है जिसमें एक कैरेक्टर key और Node * का वेक्टर होता है। struct Node{ char key; vector<Node *> children; }; इसके बाद हम createNode(int key) फंक्शन बनाते हैं जो एक int key मान लेता है और इसे नोड के key सदस्य को असाइन कर

आइए पहले उस स्ट्रक्ट को परिभाषित करें जो एक ट्री नोड को दर्शाता है जिसमें int key और इसके बाएं और दाएं चाइल्ड नोड होते हैं। यदि यह बनाया जाने वाला पहला नोड है तो यह रूट नोड है अन्यथा चाइल्ड नोड। struct Node { int data; struct Node *leftChild, *rightChild; }; इसके बाद हम createNode(int

एक संख्या जिसके अंकों का योग उनकी संबंधित स्थिति की घात के साथ संख्या के बराबर होता है, उसे डिजेरियम नंबर कहा जाता है। noOfDigits(int num) फंक्शन संख्या लेता है और लगातार संख्या को 10 से विभाजित करके अंकों की संख्या वापस करता है जब तक केवल इकाई का स्थान नहीं बचता। प्रत्येक पुनरावृत्ति पर अंक वेरिए

एक मैट्रिक्स का सारणिक केवल वर्ग मैट्रिक्स के लिए गणना किया जा सकता है पहली पंक्ति के सहखंड (cofactor) को संबंधित सहखंड के सारणिक से गुणा करके और उन्हें वैकल्पिक चिह्नों के साथ जोड़कर अंतिम परिणाम प्राप्त किया जाता है। $$A = \begin{bmatrix}a & b & c\\d & e & f \\g & h & i \\ \end{bmatrix} |A| = a(

उद्देश्य दो अंत बिंदुओं (x1,y1) और (x2,y2) दिए जाने पर एक रेखा द्वारा पार किए गए वर्गों की संख्या निर्धारित करना है। हमारी रेखा से पार होने वाले वर्गों की संख्या ज्ञात करने के लिए हमें ज्ञात करने की आवश्यकता है: x बिंदुओं के बीच अंतर (dx) = x2-x1, y बिंदुओं के बीच अंतर (dy) = y2-y1, dx और dy को जो

एक N-भुजा बहुभुज में यदि दो बच्चे A और B शीर्ष पर खड़े हैं तो हमें उस शीर्ष संख्या का निर्धारण करना होगा जहां तीसरा व्यक्ति खड़ा होना चाहिए ताकि उस व्यक्ति को A और B दोनों तक पहुंचने के लिए न्यूनतम कूद की आवश्यकता हो। ध्यान देने योग्य दो शर्तें हैं कि बहुभुज के शीर्ष घड़ी की दिशा में क्रमांकित हैं