मान लीजिए हमारे पास एक स्ट्रिंग है, हम इसके प्रत्येक अक्षर को उसके अगले अक्षर में शिफ्ट कर सकते हैं, जैसे: abc को bcd में बदला जा सकता है। हम इस ऑपरेशन को बार-बार कर सकते हैं जिससे अनुक्रम बनता है: abc → bcd → ... → xyz। यदि हमारे पास लोअरकेस अल्फाबेट वाली नॉन-खाली स्ट्रिंग्स की सूची है, तो हमें उन

मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें यूनिवैल्यू सबट्री की संख्या गिननी है। यहाँ यूनिवैल्यू सबट्री का अर्थ है कि सबट्री के सभी नोड्स का मान समान हो।इसलिए, यदि इनपुट है root = [5,1,5,5,5,null,5],तो आउटपुट 4 होगा।इसे हल करने के लिए, हम निम्न चरणों का पालन करेंगे:एक फ़ंक्शन solve() परिभाषित करें,

समस्या विवरण मान लीजिए हमारे पास एक 2D वेक्टर है, हमें उस 2D वेक्टर को फ्लैट करने के लिए एक इटरेटर डिजाइन और कार्यान्वित करना है। अलग-अलग विधियां होंगी: next() - वर्तमान तत्व का अगला तत्व लौटाएगा hasNext() - जांचेगा कि अगला तत्व मौजूद है या नहीं उदाहरण के लिए, यदि इनपुट [[1,2],[3],[4]] है तो यदि

समस्या विवरण मान लीजिए मीटिंग समय अंतराल की एक सरणी है। दो समय प्रारंभ और समाप्ति समय [[s1,e1],[s2,e2],...] हैं और प्रत्येक जोड़ी नियम (si < ei) को संतुष्ट करती है। हमें आवश्यक न्यूनतम कॉन्फ्रेंस रूम की संख्या ढूंढनी है। उदाहरण के लिए, यदि इनपुट [[0, 30], [5, 10], [15, 20]] है, तो आउटपुट 2 होगा।

समस्या विवरण मान लीजिए हमारे पास एक संख्या है। संख्याओं को इसके गुणनखंडों के गुणनफल के रूप में माना जा सकता है। जैसे, 8 = 2 x 2 x 2; = 2 x 4। हमें एक फ़ंक्शन बनाना है जो एक पूर्णांक n लेता है और इसके गुणनखंडों के सभी संभावित संयोजन लौटाता है। उदाहरण के लिए, यदि इनपुट 12 है, तो आउटपुट [[2, 6], [2,

समस्या विवरण मान लीजिए हमारे पास संख्याओं का एक अनुक्रम है; हमें जांचना है कि क्या यह बाइनरी सर्च ट्री का सही प्रीऑर्डर ट्रैवर्सल अनुक्रम है। हम मान सकते हैं कि अनुक्रम में प्रत्येक संख्या अद्वितीय है। उदाहरण के लिए, यदि इनपुट [5,2,1,3,6] है, तो आउटपुट true होगा। समाधान दृष्टिकोण स्टैक सिमुलेशन +

समस्या विवरण मान लीजिए हमारे पास n पूर्णांकों की सरणी nums है और एक लक्ष्य है, हमें सूचकांक त्रिक (i, j, k) की संख्या ढूंढनी है जहां i, j, k सभी 0 से n-1 की सीमा में हैं और nums[i] + nums[j] + nums[k] < लक्ष्य को संतुष्ट करते हैं। उदाहरण के लिए, यदि nums = [-2,0,1,3] और लक्ष्य = 2 है, तो आउटपुट 2

समस्या विवरण मान लीजिए हमारे पास n नोड्स हैं जो 0 से n-1 तक लेबल किए गए हैं और अनडायरेक्टेड एज की सूची [u,v] है। हमें एक फ़ंक्शन परिभाषित करना है जो जांचे कि क्या ये एज एक वैध ट्री बनाते हैं या नहीं। उदाहरण के लिए, यदि n = 5 और edges = [[0,1], [0,2], [0,3], [1,4]] है, तो आउटपुट true होगा। समाधान

समस्या विवरण मान लीजिए हमारे पास एक स्ट्रिंग s है, हमें इसके सभी पालिंड्रोमिक परम्यूटेशन ढूंढने हैं, कोई पुनरावृत्ति नहीं होगी। यदि कोई पालिंड्रोमिक परम्यूटेशन नहीं है, तो बस खाली स्ट्रिंग लौटाएं। उदाहरण के लिए, यदि इनपुट aabb है, तो आउटपुट [abba, baab] होगा। समाधान दृष्टिकोण बैकट्रैकिंग + वर्ण आ

समस्या विवरण मान लीजिए हमारे पास स्ट्रिंग्स की एक सूची है। हमें एक एल्गोरिदम डिजाइन करना है जो स्ट्रिंग्स की सूची को एक स्ट्रिंग में एनकोड कर सके। हमें एक डिकोडर भी बनाना है जो वापस स्ट्रिंग्स की मूल सूची में डिकोड कर सके। मान लीजिए एनकोडर और डिकोडर इन मशीनों पर इंस्टॉल हैं, और दो अलग-अलग फ़ंक्शन ह

समस्या विवरण मान लीजिए हमारे पास n लोग हैं (0 से n-1 तक लेबल किए गए) और उनमें से एक सेलिब्रिटी हो सकता है। हम कह सकते हैं कि व्यक्ति x एक सेलिब्रिटी है जब अन्य सभी n-1 लोग x को जानते हैं लेकिन x उनमें से किसी को नहीं जानता। यहां हमें यह ढूंढना है कि सेलिब्रिटी कौन है या सत्यापित करना है कि कोई नहीं

समस्या विवरण मान लीजिए हमारे पास nums नामक एक असॉर्ट की गई सरणी है, हमें इसे स्थानांतरित (in-place) करना है ताकि nums[0] = nums[2] <= nums[3]... और इसी तरह हो। उदाहरण के लिए, यदि इनपुट nums = [3,5,2,1,6,4] है, तो आउटपुट [3,5,1,6,2,4] होगा, अन्य उत्तर भी संभव हैं। समाधान दृष्टिकोण लालची दृष्टिकोण

समस्या विवरण मान लीजिए दो 1D सरणियां हैं, हमें एक इटरेटर लागू करना है जो उनके तत्वों को बारी-बारी से लौटाएगा। दो विधियां होंगी: next() - अगला तत्व प्राप्त करने के लिए hasNext() - जांचने के लिए कि अगला तत्व मौजूद है या नहीं उदाहरण के लिए, यदि इनपुट v1 = [1,2], v2 = [3,4,5,6] है, तो आउटपुट [1,3,2,

समस्या विवरण मान लीजिए हमारे पास एक बाइनरी सर्च ट्री और उसमें एक नोड है, हमें BST में उस नोड का इनऑर्डर सक्सेसर ढूंढना है। जैसा कि हम जानते हैं कि नोड p का सक्सेसर वह नोड है जिसकी कुंजी p.val से सबसे छोटी बड़ी है। उदाहरण के लिए, यदि इनपुट root = [2,1,3], p = 1 है: तो आउटपुट 2 होगा। समाधान दृष्टि

समस्या विवरण मान लीजिए हमारे पास एक m x n 2D ग्रिड है, जिसे इन तीन संभावित मानों से इनिशियलाइज़ किया गया है: -1 दीवार या बाधा के लिए 0 गेट के लिए INF अनंत के लिए अर्थात खाली कमरा यहां 2^31 - 1 = 2147483647 INF है क्योंकि हम मान सकते हैं कि गेट की दूरी 2147483647 से कम है। प्रत्येक खाली कमरे को उ

समस्या विवरण मान लीजिए दो खिलाड़ी फ्लिप गेम खेल रहे हैं। यहां हमारे पास एक स्ट्रिंग है जिसमें केवल ये दो वर्ण होते हैं: + और -। खिलाड़ी 1 और खिलाड़ी 2 बारी-बारी से दो लगातार ++ को -- में फ्लिप करते हैं। खेल तब समाप्त होता है जब एक खिलाड़ी कोई चाल नहीं चल सकता और इसलिए दूसरा विजेता होगा। हमें एक फ़ं

समस्या विवरण मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें सबसे लंबे लगातार अनुक्रम पथ की लंबाई ढूंढनी है। यदि पथ किसी प्रारंभिक नोड से ट्री में किसी भी नोड तक माता-पिता-बच्चा कनेक्शन के साथ नोड्स के किसी भी अनुक्रम को संदर्भित करता है। सबसे लंबा लगातार पथ माता-पिता से बच्चे का पालन करना चाहिए लेकिन

समस्या विवरण मान लीजिए हमारे पास दो मैट्रिक्स A और B हैं, हमें AB का परिणाम ढूंढना है। हम मान सकते हैं कि A का स्तंभ संख्या B की पंक्ति संख्या के बराबर है। उदाहरण के लिए, यदि इनपुट [[1,0,0],[-1,0,3]] और [[7,0,0],[0,0,0],[0,0,1]] है: 100-103 700000001 तो आउटपुट [[7,0,0],[-7,0,3]] होगा: 700-703

समस्या विवरण मान लीजिए एक बाइनरी ट्री है, हमें उसके नोड्स के मान का वर्टिकल ऑर्डर ट्रैवर्सल ढूंढना है। यदि दो नोड्स एक ही पंक्ति और स्तंभ में हैं, तो क्रम बाएं से दाएं होना चाहिए। उदाहरण के लिए, यदि इनपुट इस तरह का ट्री है: तो आउटपुट [[9],[3,15],[20],[7]] होगा। समाधान दृष्टिकोण BFS (लेवल ऑर्डर ट

समस्या विवरण मान लीजिए कोई शब्द है। हमें एक फ़ंक्शन परिभाषित करना है जो उस शब्द के जनरलाइज़्ड एब्रीविएशन उत्पन्न कर सके। उदाहरण के लिए, यदि इनपुट word है, तो आउटपुट [word, 1ord, w1rd, wo1d, wor1, 2rd, w2d, wo2, 1o1d, 1or1, w1r1, 1o2, 2r1, 3d, w3, 4] होगा। समाधान दृष्टिकोण बैकट्रैकिंग का उपयोग करक