पायथन में अनाड़ी फैक्टोरियल

जैसा कि हम जानते हैं कि एक धनात्मक पूर्णांक n का भाज्य n से कम या उसके बराबर सभी धनात्मक पूर्णांकों का गुणनफल होता है। तो भाज्य(10) =10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1। संचालन का निश्चित रोटेशन:इस क्रम में गुणा (*), विभाजित (/), (+) और घटाना (-) करें।

अनाड़ी भाज्य अनाड़ी(10) =10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1 की तरह है। हालाँकि, ये ऑपरेशन अभी भी अंकगणित के संचालन के सामान्य क्रम का उपयोग करके लागू होते हैं:हम सभी गुणन करते हैं और किसी भी जोड़ या घटाव चरणों से पहले विभाजन चरण, और गुणा और भाग चरणों को बाएं से दाएं संसाधित किया जाता है। हम जिस विभाजन का उपयोग कर रहे हैं वह फर्श विभाजन है जैसे कि 10 * 9/8 बराबर 11. यह गारंटी देता है कि परिणाम एक पूर्णांक है।

तो उदाहरण के लिए, यदि इनपुट 10 है, तो परिणाम 12 होगा, जैसे 12 =10 * 9/8 + 7 - 6 * 5/4 + 3 - 2 * 1

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

• ऑपरेशन ऐरे को परिभाषित करें, और ऑपरेटरों को स्टोर करें [* / + -], एक खाली स्टैक बनाएं, और एन को स्टैक में पुश करें।
• सूचकांक:=0
• N को 1 से घटाएं
• जबकि N 0 नहीं है:
  • अगर ऑपरेशन [इंडेक्स] =*, तो
    • यदि स्टैक टॉप एलिमेंट>=0 है, तो स्टैक टॉप एलिमेंट को top_element के रूप में अपडेट करें:=N * top_element
    • अन्यथा स्टैक टॉप एलिमेंट :=-1 * |N * स्टैक टॉप एलिमेंट|
  • अन्यथा यदि ऑपरेशन [इंडेक्स] / है, तो
    • यदि स्टैक टॉप एलिमेंट>=0 है, तो स्टैक टॉप एलिमेंट को top_element के रूप में अपडेट करें:=top_element / N
    • अन्यथा स्टैक टॉप एलिमेंट :=-1 * |स्टैक टॉप एलिमेंट / N|
  • अन्यथा यदि ऑपरेशन [इंडेक्स] + है, तो
    • एन को स्टैक में डालें
  • अन्यथा स्टैक में (-1 * N) डालें
  • सूचकांक:=(सूचकांक + 1) संचालन सरणी की आधुनिक लंबाई
  • N को 1 से घटाएं
• स्टैक तत्वों का रिटर्न योग।

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

उदाहरण

class Solution(object):
   def clumsy(self, N):
      operations = ["*","/","+","-"]
      stack = []
      index = 0
      stack.append(N)
      N-=1
      while N:
         if operations[index] == "*":
            if stack[-1]>=0:
               stack[-1] *=N
            else:
               stack[-1] = -1*(abs(stack[-1])*N)
         elif operations[index] == "/":
            if stack[-1]>=0:
               stack[-1] //=N
            else:
               stack[-1] = -1*(abs(stack[-1])//N)
         elif operations[index] == "+":
            stack.append(N)
         else:
            stack.append(-1*N)
         index = (index+1) % len(operations)
         N-=1
      return sum(stack)
ob = Solution()
print(ob.clumsy(10))

इनपुट

10

आउटपुट

12