यह जांचने के लिए कार्यक्रम कि क्या हम ऑपरेटरों को पायथन में रखकर 24 बना सकते हैं

मान लीजिए कि हमारे पास चार संख्याओं की एक सूची है, प्रत्येक संख्या एक निश्चित क्रम में 1 से 9 की सीमा में है। अब यदि हम संख्याओं के बीच ऑपरेटरों +, -, *, और / (/ (/ पूर्णांक विभाजन को दर्शाता है) को रखते हैं, और उन्हें कोष्ठक के साथ समूहित करते हैं, तो हमें यह जांचना होगा कि मान 24 प्राप्त करना संभव है या नहीं।

इसलिए, यदि इनपुट nums =[5, 3, 6, 8, 7] जैसा है, तो आउटपुट ट्रू होगा, जैसे (5 * 3) - 6 + (8 + 7) =24.

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

• एक फ़ंक्शन को परिभाषित करें recur() । इसमें गिरफ्तारी होगी
• उत्तर:=एक नई सूची
• मैं के लिए 0 से लेकर एआर -1 के आकार की सीमा में, करो
  • पूर्व :=पुनरावृत्ति (गिरफ्तारी [सूचकांक 0 से i तक])
  • suf:=recur(arr[index i + 1 to end])
  • प्री में प्रत्येक k के लिए, करें
    • सूफ में प्रत्येक j के लिए, करें
      • उत्तर के अंत में (k + j) डालें
      • उत्तर के अंत में (k - j) डालें
      • उत्तर के अंत में (k * j) डालें
      • यदि j 0 नहीं है, तो
        • उत्तर के अंत में (k / j का भागफल) डालें
• यदि उत्तर का आकार 0 है और गिरफ्तारी का आकार 1 है, तो
  • उत्तर के अंत में arr[0] डालें
• वापसी का जवाब
• मुख्य विधि से जांचें कि क्या 24 पुनरावृत्ति (अंक) में है या नहीं, यदि हाँ तो सही है, अन्यथा गलत है

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

उदाहरण

class Solution:
   def solve(self, nums):
      def recur(arr):
         answer = []
         for i in range(len(arr) - 1):
            pre, suf = recur(arr[: i + 1]), recur(arr[i + 1 :])
            for k in pre:
               for j in suf:
                  answer.append(k + j)
                  answer.append(k - j)
                  answer.append(k * j)
                  if j != 0:
                     answer.append(k // j)
         if len(answer) == 0 and len(arr) == 1:
            answer.append(arr[0])
         return answer
      return 24 in recur(nums)
ob = Solution()
nums = [5, 3, 6, 8, 7]
print(ob.solve(nums))

इनपुट

[5, 3, 6, 8, 7]

आउटपुट

True