पायथन में एक्सेल स्प्रेडशीट ऑपरेशन करने का कार्यक्रम?

मान लीजिए कि हमारे पास एक्सेल स्प्रेडशीट का प्रतिनिधित्व करने वाला 2 डी मैट्रिक्स है। हमें सभी कोशिकाओं और सूत्रों की गणना के साथ एक ही मैट्रिक्स खोजना होगा। एक एक्सेल स्प्रेडशीट नीचे की तरह दिखती है

कॉलम को (ए, बी, सी...) के रूप में नामित किया गया है और पंक्तियां हैं (1, 2, 3....) संख्याओं या सेल संदर्भ के बीच। (उदाहरण। "=A1+5", "=A2+B2", या "=2+5")

तो, अगर इनपुट पसंद है

तो आउटपुट होगा

जैसा कि B1 =7 (पहली पंक्ति दूसरा कॉलम) और "=A1 + A2" 7 + 3 =10 है।

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

• एक फ़ंक्शन को परिभाषित करें संकल्प() । इसमें s

  . लगेगा

• यदि s संख्यात्मक है, तो s को पूर्णांक के रूप में वापस करें

• अन्यथा हल करें (getIdx (s))

• getIdx() फ़ंक्शन को परिभाषित करें। इसमें s

  . लगेगा

• एक सूची लौटाएं जहां पहला मान s को 1 से अंत तक पूर्णांक के रूप में प्रतिस्थापित कर रहा है और दूसरा मान s[0] का ASCII है - "A" का ASCII

• फ़ंक्शन do() को परिभाषित करें। इसमें ए, बी, सेशन लगेगा

• अगर op "+" के समान है, तो

  • वापसी a + b

• यदि op "-" के समान है, तो

  • वापसी ए - बी

• अगर op "*" के समान है, तो

  • वापसी a * b

• यदि op "/" के समान है, तो

  • वापसी ए / बी

• फ़ंक्शन को हल करें () परिभाषित करें। यह मैं, जम्मू ले जाएगा

• यदि मैट्रिक्स [i, j] संख्यात्मक है तो उस मान को वापस कर दें

• अन्यथा:

  • एस:=मैट्रिक्स [i, जे]

  • अगर s[0] "=" के समान है, तो

    • s [इंडेक्स 2 से अंत तक] के सबस्ट्रिंग में प्रत्येक c के लिए, करें

      • अगर c (+, -, /, *) में कोई ऑपरेटर है, तो

        • सेशन:=सी

        • लूप से बाहर आएं

    • [a, b] :=s का सबस्ट्रिंग [इंडेक्स 1 से अंत तक] और इसे op से विभाजित करें

    • [aRes, bRes] :=[resolve(a) ,resolve(b)]

    • रिटर्न डू (aRes, bRes, op)

  • अन्यथा,

    • वापसी हल (getIdx(s))

• मैं के लिए 0 से लेकर मैट्रिक्स की पंक्ति गणना तक, करें

  • j के लिए रेंज 0 से लेकर मैट्रिक्स की कॉलम काउंट तक, करें

    • मैट्रिक्स [i, j] :=(हल करें(i, j)) स्ट्रिंग के रूप में

• रिटर्न मैट्रिक्स

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें:

उदाहरण

class Solution:
   def solve(self, matrix):
      def resolve(s):
         try:
            return int(s)
         except:
            return solve(*getIdx(s))

      def getIdx(s):
         return [int(s[1:]) - 1, ord(s[0]) - ord("A")]

      def do(a, b, op):
         if op == "+":
            return a + b
         if op == "-":
            return a - b
         if op == "*":
            return a * b
         if op == "/":
            return a / b

      def solve(i, j):
         try:
            return int(matrix[i][j])
         except:
            s = matrix[i][j]
            if s[0] == "=":
               for c in s[2:]:
                  if c in "+-/*":
                     op = c
                     break
               a, b = s[1:].split(op)
               aRes, bRes = resolve(a), resolve(b)
               return do(aRes, bRes, op)
            else:
               return solve(*getIdx(s))

      for i in range(len(matrix)):
         for j in range(len(matrix[0])):
            matrix[i][j] = str(solve(i, j))

      return matrix

ob = Solution()
matrix = [
   ["B1", "7", "0"],
   ["3", "5", "=A1+A2"]
]
print(ob.solve(matrix))

इनपुट

[["B1", "7", "0"],
["3", "5", "=A1+A2"] ]

आउटपुट

[['7', '7', '0'],
['3', '5', '10']]