मान लीजिए हमारे पास एक लिंक्ड लिस्ट है, हमें इसे उल्टा करना है। यदि लिस्ट 1 → 3 → 5 → 7 जैसी है, तो नई उल्टी लिस्ट 7 → 5 → 3 → 1 होगी। इसे हल करने के लिए हम इस दृष्टिकोण का पालन करेंगे: लिस्ट रिवर्सल को पुनरावर्ती तरीके से करने के लिए एक प्रक्रिया परिभाषित करें solve(head, back) यदि head मौजूद नही

मान लीजिए हमारे पास संख्याओं की एक सूची है। हमें जांचना है कि क्या सूची में कुछ डुप्लिकेट तत्व हैं या नहीं। यदि सूची [1,5,6,2,1,3] जैसी है, तो यह 1 वापस करेगी क्योंकि दो 1 हैं, लेकिन यदि सूची [1,2,3,4] है, तो यह false होगी, क्योंकि कोई डुप्लिकेट मौजूद नहीं है। इसे हल करने के लिए हम इस दृष्टिकोण का

मान लीजिए हमारे पास एक बाइनरी ट्री है। हमारा कार्य एक उल्टा बाइनरी ट्री बनाना है। यदि ट्री नीचे जैसा है: उल्टा ट्री इस तरह होगा: इसे हल करने के लिए हम एक पुनरावर्ती दृष्टिकोण का उपयोग करेंगे: यदि रूट null है, तो वापस करें बाएं और दाएं पॉइंटर्स को स्वैप करें बाएं सबट्री और दाएं सबट्री के लिए पुनर

मान लीजिए हमारे पास कुछ तत्वों के साथ एक लिंक्ड लिस्ट है। हमारा कार्य एक फंक्शन लिखना है जो दिए गए नोड को लिस्ट से हटा देगा। यदि लिस्ट 1 → 3 → 5 → 7 → 9 जैसी है, और 3 को हटाने के बाद, यह 1 → 5 → 7 → 9 हो जाएगी। मान लीजिए हमारे पास node पॉइंटर है जो हटाए जाने वाले नोड को इंगित करता है, हमें नोड को ह

एनाग्राम मूल रूप से किसी दिए गए स्ट्रिंग या पैटर्न के सभी क्रमपरिवर्तन हैं। यह पैटर्न खोज एल्गोरिदम थोड़ा अलग है। इस मामले में, न केवल सटीक पैटर्न खोजा जाता है, यह टेक्स्ट में दिए गए पैटर्न के सभी संभावित व्यवस्थाओं को खोजता है। यदि इनपुट ANAGRAM और NAAGARM हैं, तो वे एनाग्राम हैं, लेकिन cat और fat

मान लीजिए हमारे पास 0 से n तक की संख्याओं की एक सूची है। एक संख्या गायब है। हमें एक कुशल दृष्टिकोण में लापता संख्या ढूंढनी है। उदाहरण के लिए, यदि A = [0, 1, 2, 3, 4, 5, 7, 8, 9], तो लापता संख्या 6 है। इसे हल करने के लिए हम बाइनरी सर्च दृष्टिकोण का उपयोग करेंगे। सूची को आरोही क्रम में क्रमबद्ध करें

मान लीजिए हमारे पास कुछ संख्याओं को रखने के लिए एक सरणी है। इसमें शून्येतर मान के साथ-साथ शून्य मान भी हैं। इसलिए हमें अन्य संख्याओं के सापेक्ष क्रम को बदले बिना सभी शून्यों को दाईं ओर भेजना है। यदि सरणी [0, 1, 5, 0, 3, 8, 0, 0, 9] जैसी है, तो अंतिम सरणी [1, 5, 3, 8, 9, 0, 0, 0, 0] होगी। हल करने के

मान लीजिए हमारे पास एक संख्या n है। हमें जांचना है कि क्या संख्या 3 की घात है या नहीं। यदि संख्या n = 27 जैसी है, जो 3 की घात है, तो परिणाम true होगा, यदि n = 15, तो false होगा। हल करने के चरण हम इसे हल करने के लिए लघुगणक का उपयोग करेंगे यदि [log10(n) / log10(3)] mod 1 == 0, तो यह तीन की घात होगी,

मान लीजिए हमारे पास वर्णों की एक सरणी है। हमें बिना किसी अतिरिक्त स्थान का उपयोग किए स्ट्रिंग को उल्टा करना है। यदि स्ट्रिंग [H, E, L, L, O] जैसी है, तो आउटपुट [O, L, L, E, H] होगा। इसे हल करने के लिए हम इन चरणों का पालन करेंगे: दो पॉइंटर्स लें start = 0 और end = स्ट्रिंग की लंबाई - 1 पहले और अंति

मान लीजिए हमारे पास दो पूर्णांक a और b हैं। हमारा कार्य इन दो पूर्णांकों का योग ढूंढना है। एक प्रतिबंध यह है कि हम + या - जैसे किसी ऑपरेटर का उपयोग नहीं कर सकते। यदि a = 5 और b = 7, तो परिणाम 12 होगा। हल करने के चरण हल करने के लिए हम बिटवाइज लॉजिकल ऑपरेटर्स का उपयोग करेंगे यदि b = 0, तो a वापस करे

मान लीजिए हमारे पास एक स्ट्रिंग है और हमें स्ट्रिंग में पहला अद्वितीय वर्ण ढूंढना है। उदाहरण के लिए, यदि स्ट्रिंग people जैसी है, तो पहला अक्षर जिसकी घटना एक है वह o है। तो सूचकांक वापस किया जाएगा, जो यहां 2 है। यदि ऐसा कोई वर्ण नहीं है, तो -1 वापस करें। हल करने के चरण एक फ्रीक्वेंसी मैप बनाएं स्ट

मान लीजिए हमारे पास एक संख्या n है। हमें 1 से n तक की सभी संख्याओं का स्ट्रिंग प्रतिनिधित्व प्रदर्शित करना है, लेकिन कुछ प्रतिबंध हैं। यदि संख्या 3 से विभाज्य है, तो संख्या के बजाय Fizz लिखें यदि संख्या 5 से विभाज्य है, तो संख्या के बजाय Buzz लिखें यदि संख्या 3 और 5 दोनों से विभाज्य है, तो संख्या

मान लीजिए हमारे पास दो पूर्णांक हैं। हमें उनकी हैमिंग दूरी ढूंढनी है। हैमिंग दूरी दो संख्याओं के बीच अलग-अलग बिट काउंट की संख्या है। उदाहरण के लिए, यदि संख्याएं 7 और 15 हैं, तो वे बाइनरी में 0111 और 1111 हैं, यहां MSB अलग है, इसलिए हैमिंग दूरी 1 है। हल करने के चरण i = 31 से 0 तक b1 = x का दायां शि

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

यहां हम देखेंगे कि कैसे एक स्टैक बनाया जाए जो पुश, पॉप, टॉप, और न्यूनतम तत्व को स्थिर समय में प्राप्त कर सके। फंक्शन होंगे push(x), pop(), top() और getMin()। हल करने के चरण स्टैक को अनंत के रूप में न्यूनतम तत्व से आरंभ करें पुश ऑपरेशन push(x) के लिए यदि x < min, तो min := x अपडेट करें, x को स्टैक

मान लीजिए हमारे पास दो लिंक्ड लिस्ट A और B हैं, इन लिंक्ड लिस्ट में कुछ तत्व हैं। हमें प्रतिच्छेदन बिंदुओं का संदर्भ वापस करना है। इनपुट हैं intersectionVal = 8, A = [4,1,8,4,5], B = [5,0,1,8,4,5], skipA = 2 और skipB = 3, इनका उपयोग A से 2 तत्वों को छोड़ने और B से 3 तत्वों को छोड़ने के लिए किया जात

मान लीजिए हमारे पास एक अनसाइन्ड संख्या x है, और हम आसानी से इसका बाइनरी प्रतिनिधित्व ढूंढ सकते हैं (32-बिट अनसाइन्ड पूर्णांक)। हमारा कार्य बिट्स को उल्टा करना है। यदि बाइनरी प्रतिनिधित्व 00000000000000000000001001110100 जैसा है, तो उल्टे बिट्स 00101110010000000000000000000000 होंगे। हमें बिट्स उल्ट

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

मान लीजिए हमारे पास एक बाइनरी सर्च ट्री है। हमें दो दिए गए नोड्स का निम्नतम सामान्य पूर्वज नोड ढूंढना है। दो नोड्स p और q का LCA वास्तव में ट्री में सबसे निचला नोड है जिसमें p और q दोनों वंशज के रूप में हों। यदि बाइनरी ट्री [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5] जैसा है। ट्री इस तरह होगा: यहां 2

मान लीजिए एक कंपनी में, एक उत्पाद प्रबंधक एक टीम का नेतृत्व कर रहा है जो एक नया उत्पाद विकसित करती है। मान लीजिए नवीनतम संस्करण गुणवत्ता जांच में विफल रहता है। चूंकि प्रत्येक संस्करण पिछले संस्करण पर आधारित विकसित होता है, एक खराब संस्करण के बाद के सभी संस्करण खराब होंगे। इसलिए हमारे पास n तत्वों [