मेरा हाल ही में एक इंटरव्यू था जिसमें इंटरव्यूअर ने मुझे कुछ स्यूडोकोड दिया और उससे जुड़े सवाल पूछे। दुर्भाग्य से, मैं तैयारी की कमी के कारण उनके सवालों का जवाब नहीं दे पाया। समय की कमी के कारण मैं उनसे उस समस्या का समाधान नहीं पूछ सका। मैं वास्तव में सराहना करूंगा यदि कोई मेरा मार्गदर्शन कर सके और समस्या को समझने में मेरी मदद कर सके ताकि मैं भविष्य के लिए सुधार कर सकूं। नीचे स्यूडोकोड है:

A sample state of ‘a’: 
[[   2, NULL,    2, NULL], 
 [   2, NULL,    2, NULL], 
 [NULL, NULL, NULL, NULL], 
 [NULL, NULL, NULL, NULL]]

FUNCTION foo()
  FOR y = 0 to 3 
    FOR x = 0 to 3
      IF a[x+1][y] != NULL
        IF a[x+1][y] = a[x][y]:
          a[x][y] := a[x][y]*2
          a[x+1][y] := NULL
        END IF
        IF a[x][y] = NULL
          a[x][y] := a[x+1][y]
          a[x+1][y] := NULL
        END IF
      END IF
    END FOR
  END FOR
END FUNCTION

साक्षात्कारकर्ता ने मुझसे पूछा:

  1. उपरोक्त कोड में क्या समस्या है और मैं इसे कैसे ठीक करूं?

  2. एक बार सही करने के बाद, फंक्शन फू क्या करता है? कृपया फ़ंक्शन के परिणाम पर ध्यान दें, न कि कार्यान्वयन के विवरण पर।

  3. आप फू को अधिक सामान्य कैसे बना सकते हैं? तीन संभावित सामान्यीकरण दिशाओं की व्याख्या करें और प्रत्येक के लिए एक रणनीति का वर्णन करें, कोड लिखने की कोई आवश्यकता नहीं है!

मैंने उसका जिक्र किया:

  • मैट्रिक्स की स्थिति गलत दिखती है क्योंकि एक पूर्णांक मैट्रिक्स में शून्य मान नहीं हो सकते। डिफ़ॉल्ट रूप से उन्हें बूलियन के लिए 0, false और संदर्भ प्रकार के लिए null असाइन किए जाते हैं।
  • उपरोक्त कोड के साथ एक अन्य समस्या IF a[x+1][y] != NULL पर है, जब x 3 के बराबर होता है, तो स्थिति एक सरणी अनुक्रमणिका आउट-ऑफ-बाउंड त्रुटि उत्पन्न करेगी।

लेकिन मुझे लगा कि साक्षात्कारकर्ता मेरे उत्तर में कुछ और ढूंढ रहा था और स्पष्टीकरण से संतुष्ट नहीं था।

0
Ajay 14 मई 2018, 23:24

3 जवाब

सबसे बढ़िया उत्तर

क्या आपने गेम "2048" (लिंक टू गेम) खेला है? यदि नहीं, तो यह प्रश्न आपके लिए अधिक सहज ज्ञान युक्त नहीं होगा, और इसके कारण, मुझे लगता है कि यह एक खराब साक्षात्कार प्रश्न है।

यह जो करने का प्रयास करता है वह 2048 के खेल के एक चरण का अनुकरण करता है जहां संख्याएं ऊपर की ओर जाती हैं। संख्याएँ एक सेल द्वारा ऊपर की ओर बढ़ेंगी जब तक कि वे किसी अन्य संख्या या मैट्रिक्स बॉर्डर से नहीं टकरातीं (गुरुत्वाकर्षण के बारे में सोचें जो सभी संख्याओं को ऊपर की ओर खींचती हैं)। यदि दो संख्याएँ समान हैं, तो वे एक नई संख्या (उनका योग) को जोड़ती हैं और उत्पन्न करती हैं।

नोट: यह 2048 के खेल का ठीक एक कदम नहीं है क्योंकि संख्याएँ केवल एक सेल को ऊपर की ओर ले जाती हैं, जबकि खेल में वे "सभी तरह से" चलती हैं जब तक कि वे कुछ और हिट न करें। 2048 गेम का एक चरण प्राप्त करने के लिए, आप दिए गए फ़ंक्शन को तब तक दोहराते रहेंगे जब तक कि कोई और परिवर्तन न हो जाए।

कोड में समस्या है, जैसा कि आपने उल्लेख किया है, सरणी अनुक्रमणिका सीमा से बाहर है। इसके बजाय x = 0 to 2 से अधिक पुनरावृति करके इसे ठीक किया जाना चाहिए।

इसे और अधिक सामान्य बनाने के लिए, आपको रचनात्मक होना होगा:

  1. मुख्य सामान्यीकरण यह है कि इसे "दिशा" पैरामीटर लेना चाहिए। (यदि आपने स्वयं 2048 का खेल नहीं खेला है तो आप इसे फिर से नहीं जान पाएंगे।) गुरुत्वाकर्षण संख्याओं को ऊपर की ओर खींचने के बजाय, गुरुत्वाकर्षण किसी भी 4 कार्डिनल दिशाओं में संख्याओं को खींच सकता है।
  2. हो सकता है कि एल्गोरिथम NULL के लिए जाँच न करे, लेकिन किसी अन्य प्रहरी मूल्य (जो एक और इनपुट है) के विरुद्ध जाँच करनी चाहिए।
  3. इसे बड़े मैट्रिसेस के लिए सामान्यीकृत करना भी बहुत आसान है।
  4. हो सकता है कि कोई अन्य नियम होना चाहिए जो यह निर्धारित करता है कि संख्याएं कब संयुक्त होती हैं, और वे कितनी सटीक रूप से संयुक्त होती हैं (जरूरी नहीं कि पहले 2 गुना)। ये नियम लंबोदर के रूप में दिए जा सकते हैं।

आपके उत्तर के इस भाग के लिए:

पूर्णांक मैट्रिक्स में शून्य मान नहीं हो सकते हैं, डिफ़ॉल्ट रूप से उन्हें 0 असाइन किया जाता है, बूलियन के लिए झूठा और संदर्भ प्रकार के लिए शून्य

यह काफी हद तक इस्तेमाल की जा रही भाषा पर निर्भर है, इसलिए मैं यह नहीं कहूंगा कि यह छद्म कोड में एक त्रुटि है (जिसे किसी विशेष भाषा में नहीं माना जाता है)। उदाहरण के लिए, कमजोर टाइप की गई भाषाओं में आपके पास निश्चित रूप से int और NULL मानों वाला एक मैट्रिक्स हो सकता है।


आपने फ़ंक्शन के व्यवहार के बारे में जो कहा है उसका उल्लेख नहीं करते हैं। अगर मैं साक्षात्कारकर्ता होता, तो मैं किसी को "जोर से सोचने" और कम से कम निम्नलिखित को महसूस करते देखना चाहता हूं:

  • कोड प्रत्येक तत्व की तुलना उसके नीचे वाले से करने का प्रयास कर रहा है।
  • कुछ भी नहीं होता है जब तक कि निचला तत्व NULL न हो।
  • यदि दो तत्व समान हैं, तो निचले तत्व को NULL से बदल दिया जाता है और ऊपरी तत्व दो बार बड़ा हो जाता है।
  • यदि शीर्ष तत्व NULL है, तो निचला गैर-NULL तत्व शीर्ष तत्व के स्थान पर "स्थानांतरित" होता है।

कोड के बारे में ये अवलोकन केवल स्रोत कोड को पढ़कर प्राप्त करने के लिए सरल हैं। आप इन "नियमों" को समझते हैं या नहीं और ध्यान दें कि यह (समान) 2048 का खेल काफी हद तक इस बात पर निर्भर करता है कि आपने पहले खेल खेला है या नहीं।

10
pkpnd 15 मई 2018, 08:08

यहाँ एक ही कार्यक्रम के लिए अजगर कोड है। मैंने इस कोड में इंडेक्स को बाउंड इश्यू से बाहर कर दिया है। उम्मीद है ये मदद करेगा।

null = 0
array = [[2,null,2,null],[2,null,2,null],[null,null,null,null],[null,null,null,null]]
range = [0,1,2]
for y in range:
   for x in range:
       if array[x+1][y] != null:
           if array[x+1][y] == array[x][y]:
               array[x][y] = array[x][y]*2
               array[x+1][y] = null
           if array[x][y] == null:
               array[x][y] = array[x+1][y]
               array[x+1][y] = null
print(array)
0
Omisha gupta 13 अप्रैल 2020, 23:42

एक बार सही करने के बाद, फंक्शन फू क्या करता है? कृपया फ़ंक्शन के परिणाम पर ध्यान दें, न कि कार्यान्वयन के विवरण पर

आउटपुट होगा:

4 null 4 null
null null null null
null null null null
null null null null
-1
Rishi Raj Tandon 18 जुलाई 2019, 12:50