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

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

क्लम्सी फैक्टोरियल इस तरह है clumsy(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

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

• ऑपरेशन सरणी परिभाषित करें, और ऑपरेटर्स [*, /, +, -] संग्रहीत करें, एक खाली स्टैक बनाएं, और N को स्टैक में डालें।
• index := 0
• N को 1 से घटाएं
• जबकि N 0 नहीं है:
  • यदि operation[index] = *, तो
    • यदि स्टैक का शीर्ष तत्व >= 0 है, तो स्टैक के शीर्ष तत्व को top_element := N * top_element के रूप में अपडेट करें
    • अन्यथा स्टैक का शीर्ष तत्व := -1 * |N * स्टैक शीर्ष तत्व|
  • अन्यथा यदि operation[index] / है, तो
    • यदि स्टैक का शीर्ष तत्व >= 0 है, तो स्टैक के शीर्ष तत्व को top_element := top_element / N के रूप में अपडेट करें
    • अन्यथा स्टैक का शीर्ष तत्व := -1 * |स्टैक शीर्ष तत्व / N|
  • अन्यथा यदि operation[index] + है, तो
    • N को स्टैक में डालें
  • अन्यथा (-1 * N) को स्टैक में डालें
  • index := (index + 1) mod ऑपरेशन सरणी की लंबाई
  • 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