इंडेक्स को अनदेखा करके DateTimeIndex से DataFrame बनाने के लिए, DateTimeIndex.to_frame() मेथड का उपयोग करें। इंडेक्स को अनदेखा करने के लिए पैरामीटर index को False पर सेट करें। आवश्यक लाइब्रेरी आयात करें import pandas as pd DatetimeIndex बनाएं datetimeindex = pd.date_range(2021-10-18 07:20:32.2618116

DateTimeIndex से DataFrame बनाने के लिए, datetimeindex.to_frame() का उपयोग करें। हम परिणामी कॉलम के नाम को ओवरराइड करने के लिए name पैरामीटर सेट करते हैं। आवश्यक लाइब्रेरी आयात करें import pandas as pd DatetimeIndex बनाएं पीरियड 5 और फ्रीक्वेंसी S (सेकंड) के साथ DatetimeIndex बनाएं: datetimeindex =

मान लीजिए हमारे पास दो संख्याएं n और k हैं। हमें लंबाई k और दूरी n वाली लेक्सिकोग्राफिकली सबसे छोटी लोअरकेस स्ट्रिंग ढूंढनी है। दूरी वर्णमाला में अक्षर संख्या का योग है। उदाहरण के लिए, a की अक्षर संख्या 1 है, b की 2, y की 25, z की 26, इत्यादि। उदाहरण के लिए, यदि इनपुट है n = 15, k = 3, तो आउटपुट aam

TimeDeltaIndex ऑब्जेक्ट बनाने के लिए, pandas.TimedeltaIndex() मेथड का उपयोग करें। आवश्यक लाइब्रेरी आयात करें import pandas as pd TimeDeltaIndex ऑब्जेक्ट बनाएं हम data पैरामीटर का उपयोग करके टाइमडेल्टा-जैसा डेटा सेट करते हैं: tdIndex = pd.TimedeltaIndex(data=[10 day 5h 2 min 3us 10ns, +22:39:19.99999

मान लीजिए हमारे पास एक संख्या n है, मान लें एक कमरे में n टॉगल स्विच हैं और उस कमरे में n लोग मौजूद हैं, वे निम्नानुसार स्विच फ्लिप करते हैं: व्यक्ति 1 आता है और सभी स्विच फ्लिप करता है। व्यक्ति 2 आता है और 2 के गुणक वाले स्विच फ्लिप करता है: 2, 4, 6, ... व्यक्ति i आता है और i के गुणक वाले स्विच फ्

TimeDeltaIndex ऑब्जेक्ट से प्रत्येक तत्व के दिन निकालने के लिए, TimedeltaIndex.days प्रॉपर्टी का उपयोग करें। आवश्यक लाइब्रेरी आयात करें import pandas as pd TimeDeltaIndex ऑब्जेक्ट बनाएं tdIndex = pd.TimedeltaIndex(data=[10 day 5h 2 min 3us 10ns, +22:39:19.999999, 2 day 4h 03:08:02.000045, +21:15:45.

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, हम सूची को दो भागों part1 और part2 में विभाजित करना चाहते हैं जैसे कि part1 में प्रत्येक तत्व part2 में प्रत्येक तत्व से कम या बराबर हो। हमें part1 की सबसे छोटी संभव लंबाई ढूंढनी है (0 लंबाई नहीं)। उदाहरण के लिए, यदि इनपुट है nums = [3, 1, 2, 5,

मान लीजिए हमारे पास logs नामक संख्याओं की एक सूची है और एक मान limit है। logs[i में प्रत्येक तत्व i-वें उपयोगकर्ता द्वारा उत्पन्न लॉग्स का आकार दर्शाता है। और limit उस कुल आकार को दर्शाता है जिसे हम अपने डेटाबेस में स्टोर कर सकते हैं। हमें सबसे बड़ा x ढूंढना है जैसे कि यदि हम logs में हर लॉग को अधिक

मान लीजिए हमारे पास एक बाइनरी स्ट्रिंग s है। हमें अधिकतम एक 0 को 1 में बदलने की अनुमति है, हमें 1s के सबसे लंबे सन्निहित सबस्ट्रिंग की लंबाई ढूंढनी है। उदाहरण के लिए, यदि इनपुट है s = 1010110001, तो आउटपुट 4 होगा, क्योंकि यदि हम इंडेक्स 3 पर मौजूद जीरो को फ्लिप करते हैं, तो हमें स्ट्रिंग 1011110001

मान लीजिए हमारे पास संख्याओं की एक सूची nums और एक मान diff है, हमें उस सबसे लंबे अंकगणितीय सबसीक्वेंस की लंबाई ढूंढनी है जहां सबसीक्वेंस में किन्हीं दो लगातार संख्याओं का अंतर diff के बराबर हो। उदाहरण के लिए, यदि इनपुट है nums = [-1, 1, 4, 7, 2, 10], diff = 3, तो आउटपुट 4 होगा, क्योंकि हम सबसीक्वें

मान लीजिए हमारे पास एक नॉन-नेगेटिव मान n है, हमें उसके बाइनरी प्रतिनिधित्व में 1s के सबसे लंबे लगातार रन की लंबाई ढूंढनी है। उदाहरण के लिए, यदि इनपुट है n = 1469, तो आउटपुट 4 होगा, क्योंकि 1469 का बाइनरी प्रतिनिधित्व 10110111101 है, इसलिए चार लगातार 1s हैं। एल्गोरिदम count := 0 while n != 0: n :=

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, जहां सभी तत्व अद्वितीय हैं। हमें उस सबसे लंबे सबलिस्ट की लंबाई ढूंढनी है जिसमें लगातार तत्व हों। उदाहरण के लिए, यदि इनपुट है nums = [3, 6, 7, 5, 4, 9], तो आउटपुट 5 होगा, क्योंकि सबलिस्ट [3, 6, 7, 5, 4] है जिसमें 3 से 7 तक सभी लगातार तत्व हैं। एल्

मान लीजिए हमारे पास एक लोअरकेस स्ट्रिंग s है। इसमें अंग्रेजी अक्षर और साथ ही ? सिंबल होता है। प्रत्येक ? के लिए हमें या तो उसे हटाना होगा या किसी भी लोअरकेस अक्षर से बदलना होगा। हमें उस सबसे लंबे लगातार बढ़ते हुए सबस्ट्रिंग की लंबाई ढूंढनी है जो अक्षर a से शुरू होता है। उदाहरण के लिए, यदि इनपुट है s

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, हमें सन्निहित सख्ती से बढ़ते हुए सबलिस्ट की अधिकतम लंबाई ढूंढनी है। हमें सूची से अधिकतम एक तत्व हटाने की अनुमति है। उदाहरण के लिए, यदि इनपुट है nums = [35, 5, 6, 7, 8, 9, 12, 11, 26], तो आउटपुट 7 होगा, क्योंकि यदि हम nums से 12 हटाते हैं, तो सूची

मान लीजिए हमारे पास एक बाइनरी मैट्रिक्स है, जहां 0 खाली सेल दर्शाता है और 1 दीवार दर्शाता है। हम पहली पंक्ति के किसी भी खाली सेल से शुरू कर सकते हैं और अंतिम पंक्ति के किसी भी खाली सेल पर समाप्त करना चाहते हैं। हम बाएं, दाएं या नीचे जा सकते हैं, हमें सबसे लंबा ऐसा पथ ढूंढना है जहां हम प्रत्येक सेल क

मान लीजिए हमारे पास w नामक शब्दों की एक सूची है, जिसमें लोअरकेस स्ट्रिंग्स हैं। हमें w के सबसे लंबे सीक्वेंस की लंबाई ढूंढनी है जहां प्रत्येक पिछला शब्द अगले शब्द का प्रीफिक्स है और अगले शब्द में केवल एक नया कैरेक्टर जुड़ा हुआ है। उदाहरण के लिए, यदि इनपुट है w = [pqr, pq, m, mn, pqrs], तो आउटपुट 3 ह

मान लीजिए हमारे पास एक लोअरकेस स्ट्रिंग s है, हमें उस सबसे लंबे सबस्ट्रिंग की लंबाई ढूंढनी है जो s में कम से कम दो बार आता है। यदि ऐसा कोई स्ट्रिंग नहीं मिलता, तो 0 लौटाएं। उदाहरण के लिए, यदि इनपुट है s = abdgoalputabdtypeabd, तो आउटपुट 3 होगा, क्योंकि सबसे लंबा सबस्ट्रिंग जो एक से अधिक बार आता है व

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, हमें सबसे लंबे सबलिस्ट की लंबाई ढूंढनी है जहां 2 * (सबलिस्ट का न्यूनतम) > (सबलिस्ट का अधिकतम)। उदाहरण के लिए, यदि इनपुट है nums = [10, 2, 6, 6, 4, 4], तो आउटपुट 4 होगा, क्योंकि सबलिस्ट [6, 6, 4, 4] दी गई शर्तों को पूरा करने वाला सबसे लंबा सबलि

TimeDeltaIndex ऑब्जेक्ट से प्रत्येक तत्व के सेकंड निकालने के लिए, TimedeltaIndex.seconds प्रॉपर्टी का उपयोग करें। आवश्यक लाइब्रेरी आयात करें import pandas as pd TimeDeltaIndex ऑब्जेक्ट बनाएं tdIndex = pd.TimedeltaIndex(data=[10 day 5h 2 min 35s 3us 10ns, +22:39:19.999999, 2 day 4h 03:08:02.000045, +

TimeDeltaIndex ऑब्जेक्ट से प्रत्येक तत्व के माइक्रोसेकंड निकालने के लिए, TimedeltaIndex.microseconds प्रॉपर्टी का उपयोग करें। आवश्यक लाइब्रेरी आयात करें import pandas as pd TimeDeltaIndex ऑब्जेक्ट बनाएं tdIndex = pd.TimedeltaIndex(data=[10 day 5h 2 min 35s 3us 10ns, +22:39:19.999999, 2 day 4h 03:08: