मान लीजिए हमारे पास nums नामक एक पूर्णांक सरणी है, हमारे पास दो अन्य मान m और k भी हैं। अब, हमें m बुके बनाने हैं। एक बुके बनाने के लिए हमें बगीचे से k आसन्न फूल चाहिए। यहां बगीचे में n अलग-अलग फूल हैं, ith फूल bloomDay[i] में खिलेगा। प्रत्येक फूल का उपयोग केवल एक बुके में किया जा सकता है। हमें बगी

मान लीजिए हमारे पास n स्ट्रिंग्स की एक सरणी names है। हमें फाइल सिस्टम में n डायरेक्टरी बनानी हैं जैसे कि, iवें मिनट में, हम names[i] नाम से एक डायरेक्टरी बनाएंगे। दो फाइलों का नाम समान नहीं हो सकता, यदि हम डुप्लिकेट डायरेक्टरी नाम दर्ज करते हैं तो सिस्टम उसके नाम में (k) रूप में सफ़िक्स जोड़ देगा,

मान लीजिए हमारे पास दो सकारात्मक मान n और k हैं। अब n के सभी गुणनखंडों की सूची पर विचार करें जो आरोही क्रम में सॉर्ट की गई है, हमें इस सूची में kवां गुणनखंड ढूंढना है। यदि k से कम गुणनखंड हैं, तो -1 वापस करें। उदाहरण के लिए, यदि इनपुट n = 28 k = 4 है, तो आउटपुट 7 होगा क्योंकि, 28 के गुणनखंड [1,2,4,

मान लीजिए हमारे पास nums नामक एक बाइनरी सरणी है, हम इससे एक तत्व हटा सकते हैं। हमें परिणामी सरणी में केवल 1 वाले सबसे लंबे गैर-खाली सबएरे का आकार ढूंढना है। यदि ऐसा कोई सबएरे नहीं है, तो 0 वापस करें। उदाहरण के लिए, यदि इनपुट nums = [1,0,1,1,1,0,1,1,0] है, तो आउटपुट 5 होगा क्योंकि स्थिति 5 से 0 हटाक

मान लीजिए हमारे पास nums नामक एक सरणी है, इसमें सम संख्या में तत्व हैं, और एक मान k है। हमें nums को ठीक n/2 जोड़ों में विभाजित करना है जैसे कि प्रत्येक जोड़ का योग k से विभाज्य हो। यदि हम ऐसा कर सकते हैं तो true वापस करें, अन्यथा false। उदाहरण के लिए, यदि इनपुट nums = [9,5,3,4,7,10,20,8] k = 3 है,

मान लीजिए हमारे पास nums नामक एक सरणी और दूसरा मान k है। हमें nums के गैर-खाली सबसीक्वेंस की संख्या ढूंढनी है जैसे कि उस पर न्यूनतम और अधिकतम तत्व का योग k से कम या बराबर हो। उत्तर बहुत बड़ा हो सकता है इसलिए उत्तर को 10^9 + 7 से मोडुलो वापस करें। उदाहरण के लिए, यदि इनपुट nums = [4,6,7,8] k = 11 है,

मान लीजिए हमारे पास m x n बाइनरी मैट्रिक्स है, हमें ढूंढना है कि कितने वर्ग सबमैट्रिक्स में सभी 1 हैं। उदाहरण के लिए, यदि इनपुट इस तरह है: 0111 1111 0111 तो आउटपुट 15 होगा, क्योंकि 10 वर्ग भुजा 1 के हैं, 4 वर्ग भुजा 2 के हैं और 1 वर्ग भुजा 3 का है। कुल वर्गों की संख्या = 10 + 4 + 1 = 15। हल करन

मान लीजिए हमारे पास m x n बाइनरी मैट्रिक्स है, हमें ढूंढना है कि कितने सबमैट्रिक्स में सभी 1 हैं। उदाहरण के लिए, यदि इनपुट इस तरह है: 101 011 011 तो आउटपुट 13 होगा क्योंकि 6 (1x1) मैट्रिक्स, 3 (2x1) मैट्रिक्स, 2 (1x2) मैट्रिक्स, 1 (3x1) मैट्रिक्स और 1 (2x2) मैट्रिक्स हैं। हल करने के चरण m := म

मान लीजिए हमारे पास n सकारात्मक तत्वों वाली एक सरणी nums है। यदि हम nums के सभी गैर-खाली सन्निहित सबएरे के योग की गणना करते हैं और फिर उन्हें गैर-घटते क्रम में सॉर्ट करते हैं, जिससे n*(n+1)/2 संख्याओं की एक नई सरणी बनती है। हमें नई सरणी में इंडेक्स left से इंडेक्स right (1-इंडेक्स्ड) तक की संख्याओं

मान लीजिए हमारे पास nums नामक एक सरणी है। हम एक चाल में इस सरणी के एक तत्व को किसी भी मान में बदल सकते हैं। हमें अधिकतम 3 चालें करने के बाद nums के सबसे बड़े और सबसे छोटे मान के बीच न्यूनतम अंतर ढूंढना है। उदाहरण के लिए, यदि इनपुट nums = [3,7,2,12,16] है, तो आउटपुट 1 होगा क्योंकि हम दी गई सरणी को [

मान लीजिए हमारे पास एक बाइनरी स्ट्रिंग s है। हमें उन सबस्ट्रिंग्स की संख्या ढूंढनी है जिनके सभी वर्ण 1 हैं। उत्तर बहुत बड़ा हो सकता है इसलिए परिणाम को 10^9 + 7 से मोडुलो वापस करें। उदाहरण के लिए, यदि इनपुट s = 1011010 है, तो आउटपुट 5 होगा क्योंकि 1. चार बार 1 2. एक बार 11 हल करने के चरण m := 10^9+

मान लीजिए हमारे पास n नोड्स वाला एक अनिर्देशित भारित ग्राफ है (नोड्स 0 से क्रमांकित हैं)। यह ग्राफ एज लिस्ट के रूप में दिया गया है, प्रत्येक एज e के लिए, उस एज को पार करने की सफलता की संभावना probability[e] है। हमारे पास प्रारंभ और अंत नोड्स भी हैं, हमें प्रारंभ से अंत तक जाने के लिए अधिकतम सफलता स

रूटेड ट्री में प्रत्येक नोड के लिए, उसके सबट्री में उसी लेबल वाले नोड्स की संख्या ढूंढें (लेबल्स लोअरकेस लेटर्स)। एल्गोरिदम एज लिस्ट से ग्राफ बनाएं (अनडायरेक्टेड)। लेबल मैप बनाएं। रिकर्सिव DFS r(ni): चिल्ड्रन के काउंटर्स मर्ज करें, अपना लेबल जोड़ें, R[ni] = count[label]। पैरेंट लिंक हटाकर साइकिल अव

प्रीफिक्स सम पैरिटी (इवन/ऑड) फ्रीक्वेंसी से ऑड सम वाले सबअर्रे काउंट करें। मॉड्यूलो 10⁹+7। एल्गोरिदम freq = [1, 0] (प्रीफिक्स सम इवन=1, ऑड=0 से शुरू)। prefix = करंट प्रीफिक्स सम पैरिटी (0=इवन, 1=ऑड)। प्रत्येक x के लिए: prefix ^= (x & 1), ans += freq[1 ^ prefix], freq[prefix]++। ans % (10**9+7) रिटर

स्ट्रिंग को दो नॉन-एम्प्टी पार्ट्स p, q में स्प्लिट करें जहां डिस्टिंक्ट कैरेक्टर्स की संख्या बराबर हो। ऐसे स्प्लिट्स काउंट करें। एल्गोरिदम left और right काउंटर्स (Counter) मेंटेन करें। प्रत्येक कैरेक्टर c के लिए: left[c]++, right[c]--। अगर right[c] == 0 तो डिलीट करें। अगर len(left) == len(right) त

सभी बल्ब्स ऑफ (0) से शुरू करके, टारगेट बाइनरी स्ट्रिंग पाने के लिए मिनिमम फ्लिप्स: इंडेक्स i से अंत तक सभी फ्लिप होते हैं। एल्गोरिदम count = 0, x = 0 (करंट एक्सपेक्टेड स्टेट)। टारगेट स्ट्रिंग के प्रत्येक कैरेक्टर के लिए: अगर i != x तो count++, x = i (फ्लिप हुआ)। count रिटर्न करें। उदाहरण कोड 3 इ

दो लीफ नोड्स का पेयर गुड है अगर उनके बीच का सबसे छोटा पथ ≤ d है। पोस्ट-ऑर्डर DFS से सभी गुड पेयर्स काउंट करें। एल्गोरिदम रिकर्सिव util(root) रिटर्न करता है: प्रत्येक लीफ के लिए [depth_from_root, 0] (दूसरा मान अपडेट होता है)। लेफ्ट और राइट सबट्री के लीफ्स के लिए: डेप्थ्स इन्क्रीमेंट करें। सभी लेफ्ट-

ऐरे के पहले दो एलिमेंट्स कंपेयर करें: बड़ा इंडेक्स 0 पर रहता है, छोटा अंत में जाता है। k कंसेक्यूटिव विन्स वाला विनर ढूंढें। एल्गोरिदम prev = arr[0], count = 0। i=1 से n-1 तक: अगर arr[i] तो count++, वरना prev = arr[i], count = 1। अगर count == k तो prev रिटर्न। लूप खत्म होने पर prev रिटर्न (मैक्स ए

n×n बाइनरी मैट्रिक्स में एडजेसेंट रो स्वैप्स से मेजर डायगोनल के ऊपर सभी एलिमेंट्स 0 करने के लिए मिनिमम स्वैप्स ढूंढें। एल्गोरिदम प्रत्येक रो के लिए राइटमोस्ट 1 की पोजीशन ढूंढें → m[i] = n - j - 1 (डायगोनल से दूरी)। ग्रीडी: i=0 से n-1, ऐसी रो ढूंढें जिसका = n-i-1 हो (यानी डायगोनल के ऊपर 1 न हो)। उसे

प्रत्येक मूव i में एक अनयूज़्ड इंडेक्स चुनकर कैरेक्टर को i बार शिफ्ट कर सकते हैं (z→a रैप)। K मूव्स में s को t में बदल सकते हैं? एल्गोरिदम अगर लंबाई अलग तो False। प्रत्येक शिफ्ट डिफरेंस d (0-25) के लिए उपलब्ध मूव्स काउंट: min(1, k-d+1) + (k-d)//26। प्रत्येक कैरेक्टर पेयर के लिए जरूरी डिफरेंस चेक कर