तो वहाँ तुम हो। राहत मिली। थक कर चूर। आखिरकार आपके इंटरव्यू लेने वाले से आपके द्वारा पूछे गए ट्रिकी कोडिंग प्रश्न को हल करने के लिए एक तरीका सामने आया है। शायद आपने इसे व्हाइटबोर्ड पर भी लिखा था, लाइन बाय लाइन। और आपने अच्छा समय बनाया! आप मीटिंग में केवल 20 मिनट हैं। आपका साक्षात्कारकर्ता प्रभावित होगा।
सही?
"यह काम करेगा, लेकिन इसे और अधिक कुशलता से करने के लिए कोई विचार?"
आपका दिल डूब जाता है। आपको लगता है कि आप मुश्किल एल्गोरिथ्म डिजाइन भाग के साथ किया गया था! आप समस्या को हल करने के लिए और अधिक तरीकों के बारे में सोचने की कोशिश करते हैं, लेकिन आप सभी के बारे में सोच सकते हैं कि आप पहले से ही आ चुके हैं।
ऐसा लगभग सभी को होता है। और यह नहीं है क्योंकि वे मूर्ख हैं। ऐसा इसलिए है क्योंकि अधिकांश लोगों के पास अपने एल्गोरिदम की दक्षता में सुधार के लिए एक विधि नहीं है।
लेकिन सच्चाई यह है, बहुत सारे हैं। अगली बार जब आप रुकें, तो इन तीन सामान्य तरीकों को लागू करने का प्रयास करें।
1. हैश मैप का उपयोग करें
ये सही है। हैश मैप्स / सहयोगी सरणियों / शब्दकोशों (वे कई नामों से जाते हैं, जो इस बात पर निर्भर करता है कि आप किस प्रोग्रामिंग भाषा का उपयोग कर रहे हैं) में एल्गोरिदम के रनटाइम को नीचे लाने की जादुई क्षमता है।
उदाहरण के लिए, मान लीजिए कि एक संख्या में सबसे अधिक बार-बार संख्या ज्ञात करना था।
आपका पहला विचार कुछ छोरों में कूदना हो सकता है। हमारी प्रत्येक संख्या के लिए, इसकी गिनती का पता लगाएं और देखें कि क्या यह सबसे बड़ी है। हम प्रत्येक संख्या के लिए गणना कैसे प्राप्त करेंगे? सरणी के माध्यम से लूप, गिनती कितनी बार होती है! तो हम दो नेस्टेड छोरों के बारे में बात कर रहे हैं। छद्मकोश में:
def get_mode (संख्या): max_count = 0 मोड = num_ में संभावित_मोड के लिए null: count = 0 हमारे संख्या में संख्या के लिए_अरे: गिनती + = 1 यदि गिनती> = max_count: मोड = संभावित -mode max_count = count रिटर्न मोड
अभी, हम सरणी में प्रत्येक आइटम के लिए एक बार हमारे पूरे सरणी से गुजर रहे हैं - लेकिन हम बेहतर कर सकते हैं। बड़े O संकेतन में, वह O (n 2 ) समय है।
अगर हम अपने काउंट को हैश मैप (उनकी गिनती के लिए नंबर मैपिंग) में स्टोर करते हैं, तो हम एरे (O (n) टाइम!) के माध्यम से सिर्फ एक वॉक में समस्या को हल कर सकते हैं!
def get_mode (संख्या): max_count = 0 मोड = null counts = new HashMap, प्रत्येक मान को 0 पर शुरू करने वाले num_mode के लिए nums: counts + = 1 यदि काउंट्स> max_count: मोड = potential_mode max_count = counts रिटर्न मोड
काफी तेज!
2. बिट मैनिपुलेशन का उपयोग करें
यह वास्तव में आपको पैक से अलग कर देगा। यह हर समस्या पर लागू नहीं होता है, लेकिन यदि आप इसे अपनी जेब में रखते हैं और सही समय पर इसका भंडाफोड़ करते हैं, तो आप एक रॉकस्टार की तरह दिखेंगे।
यहाँ एक उदाहरण है: मान लीजिए कि हमारे पास एक संख्या है, जहाँ हर संख्या दो बार दिखाई देती है, केवल एक संख्या को छोड़कर जो केवल एक बार होती है। हम अकेला, गैर-दोहराया संख्या खोजने के लिए एक फ़ंक्शन लिख रहे हैं।
आपकी पहली वृत्ति हैश मैप का उपयोग करने की हो सकती है, क्योंकि हमने अभी इसके बारे में बात की थी। यह एक अच्छी वृत्ति है! और यह इस एक के लिए काम करेंगे। हम एक बहुत ही समान "गणना" नक्शा बना सकते हैं, और यह देखने के लिए कि कौन सी संख्या 1 की गिनती के साथ समाप्त होती है।
लेकिन वहाँ भी एक बेहतर तरीका है। यदि आप बिट हेरफेर से परिचित हैं, तो आप XOR से परिचित हो सकते हैं। XOR के बारे में एक बात विशेष है कि यदि आप XOR को अपने साथ रखते हैं, तो बिट्स "को रद्द करें" को 0. इस समस्या के लिए, यदि हम सरणी में हर संख्या को एक साथ XOR करते हैं, तो हमें उस एक नंबर के साथ छोड़ दिया जाएगा जो didn 'रद्द न करें:
def find_unrepeated (nums): अंक में अंक के लिए अप्राप्य = 0: unrepeated = unrepeated XOR संख्या वापसी
3. नीचे-ऊपर जाओ
एक फ़ंक्शन लिखें जो "nth" फाइबोनैचि संख्या को आउटपुट करता है, एक नंबर n। यह एक क्लासिक है, और यह खुद को पुनरावृत्ति के लिए बहुत अच्छी तरह से उधार देता है:
डीएफ़ फ़ाइब (n): यदि n 0 या 1 है: रिटर्न 1 रिटर्न फ़ाइबर (n-1) + फ़ाइबर (n-2)
लेकिन सरल पुनरावर्ती उत्तर केवल एक ही नहीं है! इस समारोह में क्या किया जाता है इसके बारे में ध्यान से सोचें मान लीजिए n 5. 5. उत्तर प्राप्त करने के लिए, यह पुनरावर्ती रूप से फ़ाइब (4) और फ़ाइब (3) कहता है। अब, उस कॉल को फ़ाइब (4) क्या करता है? इसे फ़ाइब (3) और फ़ाइब (2) कहते हैं। लेकिन हमने अभी कहा कि हमारे पास पहले से ही फ़ाइब (3) के लिए कॉल था! यह प्यारा पुनरावर्ती कार्य बहुत से दोहराए जाने वाले कार्य करता है। कुल समय लागत O (2 n ) हो जाती है। यह खराब है - ओ (n 2 ) से भी बदतर।
N पुनरावर्ती 1 से n पर जाने के बजाय, 1 से n तक "नीचे-ऊपर, " चलते हैं। यह हमें पुनरावृत्ति को छोड़ देता है:
डीएफ़ फ़ाइब (n): पिछली = 0 पिछली_पर्यावरण = 1 के लिए मैं 1 से n श्रेणी में: वर्तमान = पिछला + पिछला_ पिछला स्पष्ट पिछला_परिपूर्ण = पिछला पिछला = वर्तमान वापसी वर्तमान
कोड लंबा है, लेकिन यह बहुत अधिक कुशल है! डाउन टू ओ (एन) समय। पुनरावर्ती एल्गोरिदम के साथ एक अतिरिक्त बोनस के रूप में, हम अंतरिक्ष को बचाते हैं। उन सभी पुनरावर्ती कॉल का निर्माण कॉल स्टैक में होता है, जो स्मृति में बैठता है और हमारी अंतरिक्ष लागत के लिए मायने रखता है। हमारे पुनरावर्ती फ़ंक्शन में O (n) स्थान लागत था, लेकिन यह पुनरावृत्त O (1) स्थान लेता है।
अगली बार जब आपका साक्षात्कारकर्ता आपसे अपने समाधान की दक्षता में सुधार करने के लिए कहता है, तो इन रणनीतियों के माध्यम से चलने की कोशिश करें और देखें कि क्या वे मदद करते हैं। पर्याप्त अभ्यास के साथ, आप संभवतः स्वयं को अनुकूलित समाधान में सीधे कूदते हुए पाएंगे, और अधिक भोले समाधान को छोड़ देंगे। और यह बहुत अच्छी बात है। इसका मतलब यह नहीं है कि आप एक बेहतर साक्षात्कारकर्ता बन रहे हैं - इसका मतलब है कि आप एक बेहतर इंजीनियर बन रहे हैं।
