मान लीजिए हमारे पास इंटरवल की एक लिस्ट और एक मान point है। प्रत्येक इंटरवल interval[i] में [si, ei] होता है जो इंटरवल i का प्रारंभ समय और अंत समय दर्शाता है (दोनों समावेशी)। हमें दिए गए पॉइंट पर इंटरसेक्ट करने वाले इंटरवल की संख्या ढूंढनी है। उदाहरण के लिए, यदि इनपुट है intervals = [[2, 6],[4, 10]

मान लीजिए हमारे पास स्ट्रिंग्स की लिस्ट की लिस्ट shows है, एक इंटीजर्स की लिस्ट durations है, और एक और मान k है, यहां shows[i] और durations[i] iवें व्यक्ति द्वारा देखे गए शो और उसकी अवधि को दर्शाते हैं, हमें k सबसे अधिक देखे गए शो की कुल अवधि ढूंढनी है। उदाहरण के लिए, यदि इनपुट है shows = [The BGT

मान लीजिए हमारे पास एक ऐरे A और एक और मान k है। हमें A से तत्व लेकर आकार k की एक ऐरे arr बनानी है और अनफेयरनेस को न्यूनतम करना है। यहां अनफेयरनेस की गणना इस फॉर्मूला से की जाती है: (𝑚𝑎𝑥𝑖𝑚𝑢𝑚 𝑜𝑓 𝑎𝑟𝑟) − (𝑚𝑖𝑛𝑖𝑚𝑢𝑚 𝑜𝑓 𝑎𝑟𝑟) उदाहरण के लिए, यदि इनपुट है A = [25, 120, 350, 150, 2500,

मान लीजिए हमारे पास nums नामक संख्याओं की एक लिस्ट है, जिसमें केवल नॉन-नेगेटिव संख्याएं हैं। यदि nums में ठीक k संख्या में तत्व हैं जो k से बड़े या बराबर हैं, तो मान k ढूंढें। यदि हम ऐसा नहीं ढूंढ सकते, तो -1 लौटाएं। उदाहरण के लिए, यदि इनपुट है nums = [6, 4, 0, 8, 2, 9], तो आउटपुट होगा 4, क्योंकि

मान लीजिए हमारे पास एक बाइनरी मैट्रिक्स है; हमें मैट्रिक्स में उन तत्वों की संख्या ढूंढनी है जो निम्नलिखित नियमों का पालन करते हैं: matrix[r, c] = 1 matrix[r, j] = 0 प्रत्येक j के लिए जब j ≠ c और matrix[i, c] = 0 प्रत्येक i के लिए जब i ≠ r। उदाहरण के लिए, यदि इनपुट है: 001 100 010 तो आउटपुट

मान लीजिए हमारे पास दो ऐरे nums और values हैं, दोनों में इंटीजर हैं और nums के मान सख्ती से बढ़ रहे हैं और उनकी लंबाई भी समान है। हमें इंडेक्स i, j के एक जोड़े के लिए v का मान ढूंढना है, जैसे कि: i ≤ j जो v = values[i] + values[j] + nums[j] - nums[i] को अधिकतम करता है। उदाहरण के लिए, यदि इनपुट है

मान लीजिए हमारे पास nums नामक तत्वों की एक लिस्ट है और हमारे पास एक और मान k है। अब एक ऑपरेशन पर विचार करें जहां हम nums से एक तत्व चुनते हैं और उसे नेगेट करते हैं। हम ठीक k संख्या में ऑपरेशन कर सकते हैं। हमें अधिकतम परिणामी योग ढूंढना है जो उत्पन्न किया जा सकता है। उदाहरण के लिए, यदि इनपुट है num

मान लीजिए हमारे पास तीन पॉजिटिव संख्याएं हैं, मान लीजिए n, lower, और upper। हमें एक लिस्ट ढूंढनी है जिसकी लंबाई n है और जो सख्ती से बढ़ रही है और फिर सख्ती से घट रही है और सभी संख्याएं रेंज [lower और upper] (दोनों समावेशी) में हैं। और प्रत्येक बढ़ते और घटते भाग नॉन-खाली होने चाहिए। हमें लेक्सिकोग्र

मान लीजिए हमारे पास तीन संख्याएं n, a और b हैं। n लोगों की एक लाइन पर विचार करें। और हमें लाइन में अपनी पोजीशन के बारे में पता नहीं है। लेकिन हम जानते हैं कि हमारे आगे कम से कम a संख्या में लोग हैं और हमारे पीछे अधिकतम b संख्या में लोग हैं। हमें हमारे लिए संभावित पोजीशन की संख्या ढूंढनी है। उदाहरण

मैटप्लॉटलिब में X-एक्सिस पर सही फ्रीक्वेंसी के साथ सिग्नल का FFT (फास्ट फूरियर ट्रांसफॉर्म) प्लॉट करने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर का आकार सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। दो वेरिएबल N और m इनिशियलाइज़ करें nu की गणना के लिए। नम्पाई का उपयोग करके सिग

मान लीजिए हमारे पास लोअरकेस अल्फाबेट स्ट्रिंग्स की एक लिस्ट words है। हमें सबसे लंबे सन्निहित सबलिस्ट की लंबाई ढूंढनी है जहां प्रत्येक शब्द का पहला अक्षर समान हो। उदाहरण के लिए, यदि इनपुट है words = [she, sells, seashells, on, the, sea, shore], तो आउटपुट होगा 3, सबसे लंबा सन्निहित सबलिस्ट है [she,

मान लीजिए हमारे पास nums नामक एक लिस्ट और एक मान k है, अब एक ऑपरेशन पर विचार करें जिसके द्वारा हम लिस्ट में किसी भी नंबर का मान अपडेट कर सकते हैं। हमें सबसे लंबे सबलिस्ट की लंबाई ढूंढनी है जिसमें अधिकतम k ऑपरेशन करने के बाद दोहराए गए नंबर हों। उदाहरण के लिए, यदि इनपुट है nums = [8, 6, 6, 4, 3, 6,

पायथन मैटप्लॉटलिब में कर्व्ड लाइन के लिए शीर्षक रखने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर का आकार सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। x और y डेटा पॉइंट्स बनाएं ताकि लाइन एक कर्व हो। x और y डेटा पॉइंट्स प्लॉट करें। plt.title() मेथड का उपयोग करके कर्व प्लॉट के लिए

मान लीजिए हमारे पास एक दी गई मैट्रिक्स है, हमें एक नई मैट्रिक्स res ढूंढनी है, जिसका डायमेंशन दी गई मैट्रिक्स के समान हो जहां res[i, j] = sum of the elements of matrix[r, c] for each r ≤ i, and c ≤ j हो। उदाहरण के लिए, यदि इनपुट है: 82 74 तो आउटपुट होगा: 810 1521 समाधान दृष्टिकोण यह 2D प्

पैंडास डेटाफ्रेम में समय को इंडेक्स वैल्यू के रूप में मैटप्लॉटलिब में प्लॉट करने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर का आकार सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। time और speed दो कॉलम के साथ एक पैंडास डेटाफ्रेम बनाएं। मौजूदा कॉलम का उपयोग करके डेटाफ्रेम इंडेक्स

मान लीजिए हमारे पास एक बाइनरी स्ट्रिंग s है। अब एक ऑपरेशन पर विचार करें, जहां हम स्ट्रिंग को दो नॉन-खाली सबस्ट्रिंग s1 और s2 में विभाजित करते हैं। इस विभाजन का स्कोर s1 में 0 की संख्या का योग और s2 में 1 की संख्या का योग है। हमें अधिकतम स्कोर ढूंढना है जो हम प्राप्त कर सकते हैं। उदाहरण के लिए, यदि

एक्सटिक लेबल्स को बॉक्स में रखने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण एक नया फिगर बनाएं या मौजूदा फिगर को सक्रिय करें। फिगर का वर्तमान एक्सिस प्राप्त करें। एक्सेस के left और bottom पोजीशन सेट करें। स्पाइन्स की पोजीशन सेट करें, यानी bottom और left। एक्सटिक लेबल्स को बॉक्स में रखने के लिए,

मैटप्लॉटलिब में एनिमेटेड इमेज मैट्रिक्स प्लॉट करने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर का आकार सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। एक फिगर और सबप्लॉट्स का सेट बनाएं। *update* फंक्शन को बार-बार कॉल करके एनिमेशन बनाएं। update मेथड के अंदर, 6×6 डायमेंशन का मैट्रिक

मैटप्लॉटलिब में पोलर प्लॉट के लिए माइनर टिक्स बनाने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर का आकार सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। नम्पाई का उपयोग करके r (त्रिज्या) और theta डेटा पॉइंट्स बनाएं। वर्तमान फिगर में एक सबप्लॉट जोड़ें। step=10 के साथ 0 से 360 के बीच

मान लीजिए, हमें लंबाई n की एक स्ट्रिंग str बनानी है। स्ट्रिंग बनाने के लिए, हम दो ऑपरेशन कर सकते हैं। लागत a पर str के अंत में एक अक्षर जोड़ा जा सकता है। लागत r पर str के अंत में एक सबस्ट्रिंग sub_str जोड़ा जा सकता है। हमें स्ट्रिंग str बनाने की न्यूनतम लागत की गणना करनी है। उदाहरण के लिए, यदि इ