पायथन में अधिकतम चौड़ाई रैंप खोजने का कार्यक्रम

मान लीजिए कि हमारे पास एक सरणी संख्या है, एक रैंप एक टपल (i, j) है जिसके लिए i

इसलिए, यदि इनपुट nums =[6,0,8,2,1,5] की तरह है, तो आउटपुट 4 होगा क्योंकि अधिकतम चौड़ाई रैंप (i, j) =(1, 5) और nums पर हासिल की जाती है। [1] =0 और अंक [5] =5.

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

बी:=एक नया नक्शा
मेरे लिए 0 से लेकर अंकों के आकार तक, करें
- एक्स:=अंक [i]
- यदि x, B में है, तो
  - B[x]
    . के अंत में i डालें
- अन्यथा,
  - बी [एक्स]:=[i]
मिनी:=एक सूची शुरू में इसमें एक इंफ स्टोर करती है
मैक्सी :=एक सूची शुरू में एक -इन को इसमें संग्रहित करती है
प्रत्येक एक्स के लिए बी की सभी चाबियों की सूची सूची को क्रमबद्ध करें, करें
- मिनी के अंतिम तत्व का न्यूनतम और मिनी के अंत में न्यूनतम B[x] डालें
प्रत्येक एक्स के लिए बी की सभी चाबियों की उलटी क्रमबद्ध सूची में, करें
- मिनी के अंतिम तत्व का न्यूनतम और मिनी के अंत में न्यूनतम B[x] डालें
मैक्सी:=रिवर्स मैक्सी फिर सबरे को शुरू से दूसरे अंतिम तत्व तक ले जाएं
मिनी :=मिनी का सबरे [इंडेक्स 1 से अंत तक]
पी:=0
रेस :=-इन्फ
जबकि p <मिनी का आकार, करें
- रेस :=अधिकतम रेस और (मैक्सी[पी] - मिनी[पी])
- पी:=पी + 1
रिटर्न रेस

उदाहरण

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

def solve(nums):
   B = {}
   for i in range(len(nums)):
      x = nums[i]
      if x in B:
         B[x].append(i)
      else:
         B[x] = [i]

   mini = [float('inf')]
   maxi = [float('-inf')]
   for x in sorted(B.keys()):
      mini.append(min(mini[-1], min(B[x])))

   for x in sorted(B.keys(), reverse = True):
      maxi.append(max(maxi[-1], max(B[x])))

   maxi = maxi[::-1][:-1]
   mini = mini[1:]

   p = 0
   res = float('-inf')
   while p < len(mini):
      res = max(res, maxi[p] - mini[p])
      p += 1

   return res

nums = [6,0,8,2,1,5]
print(solve(nums))

इनपुट

[6,0,8,2,1,5]