पायथन में फेरिस व्हील से लाभ को अधिकतम करने के लिए आवश्यक न्यूनतम घुमावों का पता लगाने का कार्यक्रम

मान लीजिए कि एक फेरिस व्हील है जिसमें चार केबिन हैं और प्रत्येक केबिन में चार यात्री हो सकते हैं। पहिया वामावर्त घूमता है, और प्रत्येक घुमाव के लिए, इसमें 'रन' राशि खर्च होती है। अब हमारे पास एक सरणी 'कस्ट' है जिसमें n आइटम हैं और प्रत्येक आइटम i-वें रोटेशन से पहले फेरिस व्हील में आने की प्रतीक्षा कर रहे लोगों की संख्या को दर्शाता है। पहिया पर चढ़ने के लिए, प्रत्येक ग्राहक को 'बोर्ड' की राशि का भुगतान करना पड़ता है, और इतना पैसा पहिया के एक दक्षिणावर्त घुमाव के लिए होता है। किसी भी केबिन में सीट खाली होने पर लाइन में खड़े लोगों को इंतजार नहीं करना चाहिए। इसलिए डेटा को देखते हुए, हमें कम से कम आवश्यक घुमावों का पता लगाना होगा ताकि लाभ को अधिकतम किया जा सके।

इसलिए, यदि इनपुट cust =[6,4], बोर्ड =6, रन =4 जैसा है, तो आउटपुट 3

पहले 6 लोग लाइन में इंतजार कर रहे हैं। तो पहले 4 लोग पहले केबिन में जाते हैं, और बाकी लोग अगले केबिन की प्रतीक्षा करते हैं।

पहिया घूमता है, और दूसरा केबिन आता है। इस बीच, 4 और लोग लाइन में लग जाते हैं। तो अगले 4 लोग अगले केबिन में प्रतीक्षा कर रहे हैं।

पहिया फिर से घूमता है, और शेष तीन ग्राहक अगले केबिन में आ जाते हैं।

इसलिए, सभी ग्राहकों को सेवा प्रदान करने के लिए कम से कम तीन रोटेशन की आवश्यकता है।

इन घुमावों से प्राप्त होने वाला अधिकतम लाभ है (10 * 6) - (3 * 4) =48.

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

• रेस :=-1

• एमएसटी:=0

• टीएमपी:=0

• wt:=0

• प्रत्येक अनुक्रमणिका idx और मूल्य मान के लिए, करें

  • wt :=wt + वैल

  • chg :=न्यूनतम (4, wt)

  • wt :=wt - chg

  • tmp :=tmp + chg * बोर्ड - रन

  • अगर एमएसटी

    • रेस :=idx + 1

    • एमएसटी:=टीएमपी

• x :=wt / 4

• y:=wt मॉड 4

• अगर 4 * बोर्ड> रन करें, तो

  • रेस :=रेस + एक्स

• अगर y * बोर्ड> रन करें, तो

  • रेस :=रेस + 1

• रिटर्न रेस

उदाहरण

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

def solve(cust, board, run):
   res = -1
   mst = 0
   tmp = 0
   wt = 0
   for idx, val in enumerate(cust):
      wt += val
      chg = min(4, wt)
      wt -= chg
      tmp += chg * board - run
      if mst < tmp:
         res, mst = idx+1, tmp
   x, y = divmod(wt, 4)
   if 4 * board > run:
      res += x
   if y * board > run:
      res += 1
   return res

print(solve([6,4], 6, 4))

इनपुट

[6,4], 6, 4

आउटपुट

3