मान लीजिए हमारे पास एक पैलिंड्रोमिक स्ट्रिंग palindrome है, हमें इसमें ठीक एक अक्षर को किसी भी लोअरकेस अंग्रेजी अक्षर से बदलना है ताकि स्ट्रिंग लेक्सिकोग्राफिक रूप से सबसे छोटी संभव स्ट्रिंग बन जाए जो पैलिंड्रोम न हो। ऐसा करने के बाद हमें अंतिम स्ट्रिंग ढूंढनी है। यदि ऐसा करना संभव न हो, तो खाली स्ट

मान लीजिए हमारे पास N x M आकार का एक मैट्रिक्स है, जिसे हमें शीर्ष-बाएं से नीचे-दाएं की ओर बढ़ते क्रम में विकर्णानुसार सॉर्ट करना है। उदाहरण के लिए, यदि मैट्रिक्स निम्नलिखित है: 3311 2212 1112 तो आउटपुट मैट्रिक्स इस प्रकार होगा: 1111 1222 1233 समाधान दृष्टिकोण इस समस्या को हल करने के लिए हम

मान लीजिए हमारे पास रेस्टोरेंट्स का एक ऐरे है जहां restaurants[i] में [id_i, rating_i, veganFriendly_i, price_i, distance_i] है। हमें तीन फिल्टर्स का उपयोग करके रेस्टोरेंट्स को फ़िल्टर करना है। वेगन-फ्रेंडली फिल्टर या तो true होगा (मतलब हमें केवल उन रेस्टोरेंट्स को शामिल करना चाहिए जिनका veganFrie

मान लीजिए n शहर हैं जो 0 से n-1 तक नंबरेड हैं। अगर हमारे पास ऐरे edges है जहां edges[i] = [fromi, toi, weighti] शहरों fromi और toi के बीच एक बाईडायरेक्शनल और वेटेड एज दर्शाता है, और दिया गया इंटीजर distanceThreshold है। हमें वह शहर ढूंढना है जिसमें उन शहरों की सबसे कम संख्या हो जो किसी पथ के माध्यम

मान लीजिए हमारे पास एक ऐरे arr है। हम इंटीजर्स का एक सेट चुन सकते हैं और ऐरे में इन इंटीजर्स के सभी ऑकरेंसेज को हटा सकते हैं। हमें सेट का न्यूनतम आकार ढूंढना है ताकि ऐरे के कम से कम आधे इंटीजर्स हटा दिए जाएं। उदाहरण के लिए, अगर arr = [3,3,3,3,5,5,5,2,2,7], तो आउटपुट 2 होगा। ऐसा इसलिए क्योंकि अगर हम

मान लीजिए हमारे पास इंटीजर्स का एक ऐरे arr और दो इंटीजर्स k और threshold हैं। हमें साइज k के उन सब-ऐरे की संख्या ढूंढनी है जिनका औसत threshold से बड़ा या बराबर है। उदाहरण के लिए, अगर इनपुट है: [2,2,2,2,5,5,5,8] और k = 3 और threshold = 4, तो आउटपुट 3 होगा। क्योंकि सबऐरे [2,5,5], [5,5,5] और [5,5,8] क

मान लीजिए हमारे पास दो नंबर हैं, hour और minutes। हमें घंटे और मिनट की सुई के बीच बने छोटे कोण (सेक्साजेसिमल यूनिट्स में) को ढूंढना है। उदाहरण के लिए, अगर इनपुट hour = 12 और min = 30 है, तो रिजल्ट 165° होगा। इसे हल करने के लिए, हम इन स्टेप्स को फॉलो करेंगे: अगर h = 12, तो h := 0 सेट करें अगर m = 6

मान लीजिए हमारे पास समान साइज के दो स्ट्रिंग्स s और t हैं। एक स्टेप में हम t के किसी भी कैरेक्टर को चुनकर उसे दूसरे कैरेक्टर से रिप्लेस कर सकते हैं। हमें t को s का एनाग्राम बनाने के लिए आवश्यक न्यूनतम स्टेप्स ढूंढने हैं। नोट: एक स्ट्रिंग का एनाग्राम एक ऐसी स्ट्रिंग है जिसमें समान कैरेक्टर्स होते है

मान लीजिए हमें ProductOfNumbers नामक क्लास को इम्प्लीमेंट करना है जो दो मेथड्स को सपोर्ट करता है: add(int num): यह नंबर num को वर्तमान नंबर्स की लिस्ट के अंत में जोड़ता है। getProduct(int k): यह वर्तमान लिस्ट में अंतिम k नंबर्स का उत्पाद लौटाता है। हम मान सकते हैं कि वर्तमान लिस्ट में हमेशा कम से

मान लीजिए हमारे पास इवेंट्स का एक ऐरे है जहां events[i] = [startDayi, endDayi]। यहां हर इवेंट i startDayi पर शुरू होता है और endDayi पर खत्म होता है। हम किसी इवेंट i को किसी भी दिन d पर अटेंड कर सकते हैं जहां d startTimei और endTimei की रेंज में है (दोनों इन्क्लूसिव)। हमें ध्यान रखना होगा कि हम किस

मान लीजिए एक सुपरमार्केट में सेल है, हर n कस्टमर पर डिस्काउंट मिलेगा। मान लीजिए सुपरमार्केट में कुछ प्रोडक्ट्स हैं जहां i-वें प्रोडक्ट की ID products[i] है और इस प्रोडक्ट की प्रति यूनिट कीमत prices[i] है। यहां सिस्टम कस्टमर्स की संख्या गिनेगा और जब n-वां कस्टमर आएगा तो उसे बिल पर डिस्काउंट मिलेगा।

मान लीजिए हमें a, b और c कैरेक्टर्स से बनी एक स्ट्रिंग s दी गई है। हमें उन सबस्ट्रिंग्स की संख्या लौटानी है जिनमें इन तीनों कैरेक्टर्स a, b और c का कम से कम एक ऑकरेंस हो। उदाहरण के लिए, अगर स्ट्रिंग abcabc है, तो आउटपुट 10 होगा, क्योंकि a, b और c के कम से कम एक ऑकरेंस वाले सबस्ट्रिंग्स हैं: abc, ab

मान लीजिए हमारे पास 0 से n-1 तक नंबरेड n बाइनरी ट्री नोड्स हैं जहां नोड i के दो चिल्ड्रन leftChild[i] और rightChild[i] हैं, हमें true कहना है यदि और केवल यदि सभी दिए गए नोड्स ठीक एक वैलिड बाइनरी ट्री बनाते हैं। जब नोड i का कोई लेफ्ट चाइल्ड नहीं होता तो leftChild[i] -1 के बराबर होगा, इसी तरह राइट चा

मान लीजिए हमारे पास एक इंटीजर num है, हमें एब्सोल्यूट डिफरेंस में सबसे निकट दो इंटीजर्स ढूंढने हैं जिनका गुणनफल num + 1 या num + 2 के बराबर हो। हमें किसी भी क्रम में दो इंटीजर्स ढूंढने हैं। उदाहरण के लिए, अगर इनपुट 8 है, तो आउटपुट [3, 3] होगा, num + 1 के लिए यह 9 होगा, क्लोजेस्ट डिवाइजर्स 3 और 3 है

मान लीजिए हमारे पास एक बाइनरी ट्री रूट और एक लिंक्ड लिस्ट है जिसका हेड पहला नोड है। हमें True लौटाना है अगर लिंक्ड लिस्ट में हेड से शुरू होने वाले सभी एलिमेंट्स बाइनरी ट्री में किसी डाउनवर्ड पथ से मेल खाते हैं, अन्यथा False। उदाहरण के लिए, अगर ट्री है: और लिंक्ड लिस्ट [1,4,2,6] है, तो आउटपुट true

मान लीजिए हमारे पास एक बाइनरी ट्री रूट है, बाइनरी ट्री के लिए एक जिगजैग पथ इस प्रकार परिभाषित है: बाइनरी ट्री में किसी भी नोड और एक डायरेक्शन (या तो राइट या लेफ्ट) को चुनें। अगर वर्तमान डायरेक्शन राइट है तो करंट नोड के राइट चाइल्ड की ओर बढ़ें अन्यथा लेफ्ट चाइल्ड की ओर बढ़ें। फिर डायरेक्शन को राइट

मान लीजिए हमारे पास n बल्ब्स वाला एक कमरा है, ये 1 से n तक नंबरेड हैं, बाएं से दाएं एक पंक्ति में व्यवस्थित। प्रारंभ में, सभी बल्ब्स बंद हैं। मोमेंट k पर (k के लिए 0 से n-1 की रेंज में), हम light[k] बल्ब को ऑन करते हैं। एक बल्ब केवल तभी नीला होता है जब वह ऑन हो और उसके सभी पिछले बल्ब (बाएं तरफ) भी

मान लीजिए एक कंपनी में n कर्मचारी हैं जिनमें प्रत्येक कर्मचारी के लिए एक यूनिक ID है। ये IDs 0 से n-1 तक हैं। कंपनी का हेड headID वाला है। प्रत्येक कर्मचारी का एक डायरेक्ट मैनेजर होता है जो मैनेजर ऐरे में दिया गया है जहां manager[i] i-वें कर्मचारी का डायरेक्ट मैनेजर है, manager[headID] = -1। यह भी

मान लीजिए हमारे पास दो बाइनरी ट्रीज़ original और cloned हैं और original ट्री में एक नोड target का रेफरेंस दिया गया है। क्लोन किया गया ट्री वास्तव में original ट्री की एक कॉपी है। हमें क्लोन किए गए ट्री में उसी नोड का रेफरेंस ढूंढना है। तो अगर ट्री नीचे जैसा है और टारगेट 3 है, तो आउटपुट 3 होगा। इसे

मान लीजिए हम एक ऐसा स्टैक डिजाइन करना चाहते हैं जो निम्न ऑपरेशन्स को सपोर्ट करता है: CustomStack(int maxSize) यह ऑब्जेक्ट को maxSize से इनिशियलाइज़ करता है जो स्टैक में एलिमेंट्स की अधिकतम संख्या है या कुछ नहीं करता अगर स्टैक maxSize तक पहुंच गया है। void push(int x) यह x को स्टैक के टॉप पर इंसर्ट