Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> Python

पायथन में बेसिक कैलकुलेटर II

मान लीजिए कि हमें एक साधारण व्यंजक स्ट्रिंग का मूल्यांकन करने के लिए एक बुनियादी कैलकुलेटर लागू करना है। एक्सप्रेशन स्ट्रिंग में केवल गैर-ऋणात्मक पूर्णांक होंगे, कुछ ऑपरेटर जैसे, +, -, *, / और रिक्त स्थान। पूर्णांक भाग को केवल भागफल भाग लेना चाहिए।

तो अगर इनपुट “3+2*2” जैसा है, तो आउटपुट 7 होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

  • एक स्टैक को परिभाषित करें, i:=0, x:=एक खाली स्ट्रिंग
  • एस में प्रत्येक वर्ण j के लिए
    • यदि j एक रिक्त वर्ण नहीं है
      • x में j जोड़ें
  • s :=x, n :=x की लंबाई
  • जबकि मैं
  • यदि s[i] '/' है, तो
    • मैं 1 से बढ़ाएँ
    • num :=ith इंडेक्स से शुरू होने वाला नंबर, फिर i को नंबर के आखिरी कैरेक्टर के रूप में अपडेट करें
    • यदि स्टैक टॉप एलिमेंट <0 है, तो स्टैक टॉप एलिमेंट को -(स्टैक टॉप / num) के रूप में अपडेट करें, अन्यथा स्टैक टॉप एलिमेंट को (स्टैक टॉप / num) के रूप में अपडेट करें
  • अन्यथा जब s[i] ="*"
    • मैं 1 से बढ़ाएँ
    • num :=ith इंडेक्स से शुरू होने वाला नंबर, फिर i को नंबर के आखिरी कैरेक्टर के रूप में अपडेट करें
    • स्टैक टॉप:=num * स्टैक टॉप
  • अन्यथा जब s[i] ='-'
    • मैं 1 से बढ़ाएँ
    • num :=ith इंडेक्स से शुरू होने वाला नंबर, फिर i को नंबर के आखिरी कैरेक्टर के रूप में अपडेट करें
    • स्टैक में -num डालें
  • अन्यथा
    • num :=ith इंडेक्स से शुरू होने वाला नंबर, फिर i को नंबर के आखिरी कैरेक्टर के रूप में अपडेट करें
    • स्टैक में संख्या डालें
    • मैं 1 से बढ़ाएँ
  • स्टैक के तत्वों का रिटर्न योग
  • आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

    उदाहरण

    class Solution(object):
       def calculate(self, s):
          """
          :type s: str
          :rtype: int
          """
          stack = []
          i = 0
          x=""
          for j in s:
          if j !=" ":
          x+=j
          s = x
          n = len(s)
          while i<n:
             if s[i] == '/':
                i+=1
             num,i = self.make_num(s,i)
             if stack[-1]<0:
                stack[-1] = -1*(abs(stack[-1])/num)
             else:
                stack[-1] = stack[-1]/num
          elif s[i] == '*':
             i+=1
             num,i = self.make_num(s,i)
             stack[-1] = stack[-1]*num
          elif s[i] == '-':
             i+=1
             num,i = self.make_num(s,i)
             stack.append(-num)
          elif s[i] =='+':
             i+=1
             num,i = self.make_num(s,i)
             stack.append(num)
          else:
             num,i = self.make_num(s,i)
             stack.append(num)
             i+=1
             return sum(stack)
       def make_num(self,s,i):
          start = i
          while i<len(s) and s[i]!= '/' and s[i]!= '*' and s[i]!= '-' and s[i]!='+':
          i+=1
       return int(s[start:i]),i-1

    इनपुट

    "3+2*2"

    आउटपुट

    7

    1. पायथन में बाइनरी ट्री पोस्टऑर्डर ट्रैवर्सल

      मान लीजिए कि हमारे पास एक बाइनरी ट्री है। हमें पुनरावृत्त दृष्टिकोण का उपयोग करके इस पेड़ के पोस्ट ऑर्डर ट्रैवर्सल को खोजना होगा। तो अगर पेड़ जैसा है - तब आउटपुट होगा:[9,15,7,10,-10] इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - यदि रूट शून्य है, तो खाली सरणी लौटाएं एक सरणी रिट बनाएं

    1. पायथन में हिस्टोग्राम में सबसे बड़ा आयत

      मान लें कि हमारे पास एक पूर्णांक सरणी है जो हिस्टोग्राम की ऊंचाई का प्रतिनिधित्व कर रही है। प्रत्येक बार में इकाई चौड़ाई होती है। हमें इस प्रकार सबसे बड़ा क्षेत्रफल आयत ज्ञात करना है - इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - स्टैक बनाएं, मैं सेट करें:=0, उत्तर:=0 जबकि मैं <ऊंचाई का

    1. पायथन में वर्षा जल को फंसाना

      मान लीजिए कि हमारे पास n गैर-ऋणात्मक पूर्णांकों की एक सरणी है। ये एक ऊंचाई के नक्शे का प्रतिनिधित्व कर रहे हैं जहां प्रत्येक बार की चौड़ाई 1 है, हमें गणना करनी होगी कि बारिश के बाद यह कितना पानी फंसा सकता है। तो नक्शा इस तरह होगा - यहां हम देख सकते हैं कि 6 नीले बॉक्स हैं, इसलिए आउटपुट 6 होगा। इ