xyz। यदि हमारे पास गैर-रिक्त स्ट्रिंग्स की एक सूची है जिसमें केवल लोअरकेस अक्षर हैं, तो हमें उन सभी स्ट्रिंग्स को समूहित करना होगा जो समान स्थानांतरण अनुक्रम से संबंधित हैं। इसलिए, यदि इनपुट [abc, bcd, acef, xyz, az, ba, a, z] जैसा है, तो आउटपुट [[abc] होगा। ,bcd,,xyz], [az,,ba], [acef], [a,,z] ]

मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें यूनी-वैल्यू सबट्री की संख्या गिननी होगी। यहां यूनी-वैल्यू सबट्री इंगित करता है कि सबट्री के सभी नोड्स का मान समान है। तो, अगर इनपुट रूट की तरह है =[5,1,5,5,5,5,नल,5], तो आउटपुट 4 . होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - एक फ़ंक्शन हल

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

मान लीजिए कि बैठक के समय अंतराल की एक सरणी है। दो बार प्रारंभ और समाप्ति समय हैं [[s1,e1],[s2,e2],...] और प्रत्येक जोड़ी नियम को संतुष्ट करती है (si

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

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

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

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

मान लीजिए कि हमारे पास एक स्ट्रिंग है, हमें इसके सभी पैलिंड्रोमिक क्रमपरिवर्तन खोजने होंगे, कोई दोहराव नहीं होगा। यदि कोई पैलिंड्रोमिक क्रमचय नहीं है, तो बस खाली स्ट्रिंग लौटाएं। इसलिए, यदि इनपुट आब जैसा है, तो आउटपुट [अब्बा, बाब] होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - एक सरणी रि

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

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

मान लीजिए कि हमारे पास nums नामक एक अनसोल्ड ऐरे है, हमें इसे इन-प्लेस पर फिर से व्यवस्थित करना होगा जैसे कि nums[0] =nums[2] <=nums[3].... और इसी तरह। इसलिए, यदि इनपुट संख्या =[3,5,2,1,6,4] की तरह है, तो आउटपुट [3,5,1,6,2,4] होगा, कुछ अन्य उत्तर हो सकते हैं। इसे हल करने के लिए, हम इन चरणों का पालन

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

मान लीजिए कि हमारे पास एक बाइनरी सर्च ट्री है और उसमें एक नोड है, तो हमें उस नोड के इन-ऑर्डर सक्सेसर को BST में खोजना होगा। जैसा कि हम जानते हैं कि एक नोड p का उत्तराधिकारी वह नोड होता है जिसकी सबसे छोटी कुंजी p.val से बड़ी होती है। इसलिए, यदि इनपुट रूट =[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]] जैसा है , 1 0 0 -1 0 3 7 0 0 0 0 0 0 0 1 तो आउटपुट [[7,0,0],[-7,0,3]] . होगा 7

मान लीजिए कि एक बाइनरी ट्री है, हमें इसके नोड्स के मानों का वर्टिकल ऑर्डर ट्रैवर्सल खोजना होगा। यदि दो नोड एक ही पंक्ति और स्तंभ में हैं, तो क्रम बाएं से दाएं होना चाहिए। तो, अगर इनपुट पसंद है, तो आउटपुट [[9],[3,15],[20],[7]] . होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - एक नक्शा प

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