पायथन में निकटतम मिठाई लागत खोजने का कार्यक्रम

मान लीजिए कि हमारे पास n आइटम के साथ बेसकॉस्ट नामक दो सरणियाँ हैं, हम उनमें से m आइटम के साथ बेस और टॉपिंग कॉस्ट का चयन कर सकते हैं, हम टॉपिंग का चयन कर सकते हैं और एक लक्ष्य मान भी रख सकते हैं। मिठाई बनाने के लिए हमें इन नियमों का पालन करना होगा।

• बिल्कुल एक आधार होना चाहिए।

• हम एक या अधिक टॉपिंग जोड़ सकते हैं या बिल्कुल भी टॉपिंग नहीं कर सकते हैं।

• प्रत्येक प्रकार की टॉपिंग में से अधिकतम दो हैं।

यहाँ बेसकॉस्ट [i] ith आइसक्रीम बेस की कीमत को दर्शाता है। टॉपिंग कॉस्ट [i] किसी एक टॉपिंग की कीमत को दर्शाता है। लक्ष्य मूल्य मिठाई के लिए लक्षित मूल्य का प्रतिनिधित्व कर रहा है। हमें जितना संभव हो सके लक्ष्य के करीब कुल लागत के साथ एक मिठाई बनानी होगी। हमें लक्षित करने के लिए मिठाई की निकटतम संभावित लागत का पता लगाना होगा। यदि एक से अधिक उत्तर हैं, तो नीचे वाला उत्तर दें।

इसलिए, यदि इनपुट बेसकॉस्ट्स =[2,8], टॉपिंग कॉस्ट्स =[4,5], टारगेट =12 की तरह है, तो आउटपुट 12 होगा क्योंकि हम लागत 8 के साथ आधार ले सकते हैं, फिर लागत के साथ पहली टॉपिंग का 1 लें। 4, और कोई टाइप2 टॉपिंग नहीं, इसलिए कुल लागत 8+4 =12.

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

• best_cost :=आधार लागत[0]

• बी के लिए 0 से लेकर बेसकॉस्ट के आकार तक - 1, करें

  • बिटमास्क :=एक सरणी जिसका आकार टॉपिंग के आकार के समान हैलागत और 0 से भरें

  • निम्नलिखित को असीम रूप से करें, करें

    • current_price :=बेसकॉस्ट्स[b]

    • j के लिए 0 से लेकर बिटमास्क -1 के आकार तक, करें

      • current_price :=current_price + bitmask[j] * toppingCosts[j]

    • अगर current_price - लक्ष्य 0 के समान है, तो

      • वापसी लक्ष्य

    • अन्यथा जब |current_price - लक्ष्य| <|best_cost - target|, फिर

      • best_cost :=current_price

    • अन्यथा जब |current_price - लक्ष्य| वही है |best_cost - target|, फिर

      • अगर current_price

        • best_cost :=current_price

    • अगर 0 बिटमास्क में नहीं है और 1 बिटमास्क में नहीं है, तो

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

    • मेरे लिए 0 से लेकर बिटमास्क -1 के आकार की सीमा में है, करें

      • अगर बिटमास्क[i] 2 के समान नहीं है, तो

        • बिटमास्क[i] :=बिटमास्क[i] + 1

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

      • अन्यथा,

        • बिटमास्क[i] :=0

• सर्वोत्तम_लागत लौटाएं

उदाहरण

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

def solve(baseCosts, toppingCosts, target):
   best_cost = baseCosts[0]

   for b in range(len(baseCosts)):
      bitmask = [0] * len(toppingCosts)
      while True:
         current_price = baseCosts[b]
         for j in range(len(bitmask)):
            current_price += bitmask[j] * toppingCosts[j]
         if current_price - target == 0:
            return target
         elif abs(current_price - target) < abs(best_cost - target):
            best_cost = current_price
         elif abs(current_price - target) == abs(best_cost - target):
            if current_price < best_cost:
               best_cost = current_price

         if 0 not in bitmask and 1 not in bitmask:
            break
         for i in range(len(bitmask)):
            if bitmask[i] != 2:
               bitmask[i] += 1
               break
            else:
               bitmask[i] = 0
   return best_cost

baseCosts = [2,8]
toppingCosts = [4,5]
target = 12
print(solve(baseCosts, toppingCosts, target))

इनपुट

[2,8], [4,5], 12

आउटपुट

12