पायथन में बच्चे और विशाल कदमों द्वारा गंतव्य तक पहुंचने के लिए आवश्यक इष्टतम चरणों की संख्या खोजने के लिए कार्यक्रम

मान लीजिए कि हमारे पास प्रश्नों की एक सूची है, जहां प्रत्येक प्रश्न Q[i] में एक त्रिक [a_i, b_i और d_i] है। मान लीजिए कि हम शुरू में स्थिति (0, 0) पर हैं, फिर एक चरण में हम किसी स्थिति (x1, y1) से (x2, y2) पर जा सकते हैं, जहां इन दो बिंदुओं के बीच यूक्लिडियन दूरी कम से कम a और अधिक से अधिक b है। अब प्रत्येक प्रश्न के लिए हमें (0, 0) से (d_i, 0) तक पहुँचने के लिए आवश्यक न्यूनतम चरणों की संख्या ज्ञात करनी होगी।

इसलिए, यदि इनपुट Q =[(2,3,1), (1,2,0), (3,4,11)] जैसा है, तो आउटपुट [2, 0, 3] होगा क्योंकि पहली क्वेरी (0, 0) से a =2 के साथ हम जा सकते हैं $\left(\frac{1}{2},\frac{\sqrt{15}}{2}\right)$ फिर (1, 0) इसलिए हमें दो चरणों की आवश्यकता है, इसलिए आउटपुट 2 है, अगली क्वेरी के लिए d 0 है, इसलिए हमें किसी भी चरण को स्थानांतरित करने की आवश्यकता नहीं है, इसलिए आउटपुट 0 है। और तीसरे के लिए b =4 और a =3 चाल (0, 0 ) से (4, 0) फिर से (8, 0) फिर (11, 0) तक।

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

• फ़ंक्शन को परिभाषित करें steps() । इसमें a, b, d
. लगेगा
• मिमी:=न्यूनतम ए, बी
• मिमैक्स:=अधिकतम ए, बी
• यदि d 0 है, तो
  • वापसी 0
• यदि d या तो mmin या mmmax है, तो
  • वापसी 1
• यदि डी <एममैक्स, तो
  • वापसी 2
• (d / mmmax) की अधिकतम सीमा लौटाएं
• मुख्य विधि से, निम्न कार्य करें -
• res :=एक नई सूची
• Q में प्रत्येक q के लिए, करें
  • (ए, बी, डी) :=क्यू
  • रेस के अंत में चरणों (ए, बी, डी) का परिणाम डालें
• रिटर्न रेस

उदाहरण

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

from math import ceil

def steps(a, b, d):
   mmin = min(a, b)
   mmax = max(a, b)
   if d is 0:
      return 0
   if d in [mmin, mmax]:
      return 1
   if d < mmax:
      return 2
   return ceil(d / mmax)

def solve(Q):
   res = []
   for q in Q:
      a, b, d = q
      res.append(steps(a, b, d))
   return res

Q = [(2,3,1), (1,2,0), (3,4,11)]
print(solve(Q))

इनपुट

[(2,3,1), (1,2,0), (3,4,11)]

आउटपुट

[2, 0, 2.0]