पायथन में आरोही क्रम में तत्वों को हटाने के बाद सूची के सूचकांक प्राप्त करने का कार्यक्रम

मान लीजिए कि हमारे पास अलग-अलग मानों की एक सूची है और हम प्रत्येक संख्या को गैर-घटते क्रम में हटाना चाहते हैं। हमें संख्याओं के सूचकांकों को उनके विलोपन के क्रम में खोजना होगा।

इसलिए, यदि इनपुट संख्या =[4, 6, 2, 5, 3, 1] की तरह है, तो आउटपुट [5, 2, 3, 0, 1, 0] होगा क्योंकि हम 1 को हटाते हैं, इसलिए सरणी है [ 4, 6, 2, 5, 3], फिर 2 को हटा दें, सरणी [4, 6, 5, 3] है, फिर 3 को हटाकर हमें [4, 6, 5] मिलता है, फिर 4 को हटाकर हमें [6, 5] मिलता है। , 5 को हटा दें, [6] और अंत में 6 को हटा दें।

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

• एक फ़ंक्शन को परिभाषित करें my_sort() । इसमें खर्च होगा
• इंड्स का आकार <=1, तो
  • इंड्स रिटर्न करें
• क्रमबद्ध_इंड्स:=एक नई सूची
• मध्य :=इंडस का आकार / 2
• बाएं:=my_sort(इंड्स[इंडेक्स 0 से मिड]), राइट:=my_sort(इंड्स [इंडेक्स मिड से एंड तक])
• i :=0, j :=0
• जबकि मैं <बाएं का आकार और j <दाएं का आकार, करते हैं
  • अगर अंक [बाएं[i]] <अंक [दाएं[जे]], तो
    सॉर्ट किए गए_इंड्स के अंत में
    • बाएं डालें[i]
    • i :=i + 1
  • अन्यथा,
    सॉर्ट किए गए_इंड्स के अंत में
    • दाएं डालें[j]
    • बड़ा [दाएं [जे]]:=बड़ा [दाएं [जे]] + बाएं का आकार - i
    • j :=j + 1
• सॉर्ट किए गए_इंड्स में बाएं [इंडेक्स i से अंत तक] डालें
• सॉर्टेड_इंड्स में राइट [इंडेक्स जे से एंड तक] डालें
• सॉर्ट किए गए_इंड्स लौटाएं
• मुख्य विधि से निम्न कार्य करें -
• बड़ा :=आकार अंकों की एक नई सूची और 0 से भरें
• my_sort(0 से लेकर अंकों के आकार तक)
• num_larger_pairs :=प्रत्येक के लिए जोड़ी बनाएं (अंक, बड़ा) और उन्हें सॉर्ट करें
• ई [1] के साथ num_larger_pairs में सभी ई के लिए एक सूची लौटाएं

उदाहरण (पायथन)

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

class Solution:
   def solve(self, nums):
      return solve(nums)
def solve(nums):
   def my_sort(inds):
      if len(inds) <= 1:
         return inds
      sorted_inds = []
      mid = len(inds) // 2
      left, right = my_sort(inds[:mid]), my_sort(inds[mid:])
      i = j = 0
      while i < len(left) and j < len(right):
         if nums[left[i]] < nums[right[j]]:
            sorted_inds.append(left[i])
            i += 1
         else:
            sorted_inds.append(right[j])
            larger[right[j]] += len(left) - i
            j += 1
      sorted_inds.extend(left[i:])
      sorted_inds.extend(right[j:])
      return sorted_inds
   larger = [0] * len(nums)
   my_sort(range(len(nums)))
   num_larger_pairs = sorted(zip(nums, larger))
   return [e[1] for e in num_larger_pairs]
ob = Solution()
nums = [4, 6, 2, 5, 3, 1]
print(ob.solve(nums))

इनपुट

[4, 6, 2, 5, 3, 1]

आउटपुट

[5, 2, 3, 0, 1, 0]