उन तत्वों की सूची खोजने का कार्यक्रम जो सीमा से कम हैं और पायथन में XOR अधिकतम है

मान लीजिए कि हमारे पास संख्याओं की एक सूची है और प्रश्नों की एक सूची है जहां प्रत्येक क्वेरी में [x, सीमा] है। हमें एक ऐसी सूची ढूंढनी है कि प्रत्येक प्रश्न [x, सीमा] के लिए, हम अंकों में एक तत्व e पाते हैं जैसे कि e सीमा और e XOR x अधिकतम हो। अगर ऐसा कोई तत्व नहीं है, तो -1 लौटाएं।

इसलिए, यदि इनपुट संख्या =[3, 5, 9] क्वेरीज़ =[[4, 6], [2, 0]] की तरह है, तो आउटपुट [3, -1] होगा, जैसा कि पहली क्वेरी के लिए है, हम संख्या में 2 या 4 का उपयोग कर सकते हैं। 3 ^ 4 =7 जबकि 5 ^ 4 =3 इसलिए हम 3 का चयन करते हैं जो बड़ा एक्सओआर उत्पन्न करता है। दूसरी क्वेरी में, ऐसी कोई संख्या नहीं है जो 0 से कम या उसके बराबर हो, इसलिए हम इसे -1 पर सेट करते हैं।

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

• ट्राई :=एक नया नक्शा

• फ़ंक्शन बिट्स() को परिभाषित करें। इसमें मुझे लगेगा

• i

  . का 32 बिट बाइनरी प्रतिनिधित्व लौटाएं

• फ़ंक्शन डालने को परिभाषित करें। इसमें मुझे लगेगा

• नोड:=ट्राई

• बिट्स (i) में प्रत्येक सी के लिए, करें

  • नोड:=अगर c नोड में नहीं है, तो उसके अंदर एक खाली नक्शा डालें

• नोड[2] :=मैं

• फ़ंक्शन क्वेरी () को परिभाषित करें। इसमें मुझे लगेगा

• नोड:=ट्राई

• बिट्स (i) में प्रत्येक सी के लिए, करें

  • आरसी:=सी एक्सओआर 1

  • नोड:=नोड [आरसी] यदि मौजूद है अन्यथा नोड [सी]

• वापसी नोड[2]

• मुख्य विधि से निम्न कार्य करें -

• सूची ए को क्रमबद्ध करें

• बी:=प्रत्येक क्वेरी इंडेक्स i और क्वेरी मान x और सीमा के लिए फॉर्म (i, x, सीमा) में तत्वों की एक सूची। फिर इसे सीमा के आधार पर क्रमबद्ध करें

• (जे, एन, उत्तर) :=(0, ए का आकार, प्रश्नों के समान आकार की एक सूची, -1 से भरें)

• प्रत्येक अनुक्रमणिका के लिए i और मान x और B में सीमा, करें

  • जबकि j

    • सम्मिलित करें (ए [जे])

    • जे:=जे + 1

  • अगर j गैर-शून्य है, तो

    • ans[i] :=query(x)

• वापसी उत्तर

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

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

class Solution:
   def solve(self, A, queries):
      trie = {}
      def bits(i):
         return map(int, bin(i)[2:].zfill(32))
      def insert(i):
         node = trie
         for c in bits(i):
            node = node.setdefault(c, {})
         node[2] = i
      def query(i):
         node = trie
         for c in bits(i):
            rc = c ^ 1
            node = node.get(rc, node.get(c))
         return node[2]
      A.sort()
      B = sorted([(i, x, limit) for i, (x, limit) in enumerate(queries)], key=lambda x: x[2])
j, n, ans = 0, len(A), [-1] * len(queries)
      for i, x, limit in B:
         while j < n and A[j] <= limit:
            insert(A[j])
            j += 1
         if j:
            ans[i] = query(x)
      return ans
ob = Solution()
nums = [3, 5, 9]
queries = [
   [4, 6],
   [2, 0]
]
print(ob.solve(nums, queries))

इनपुट

[3, 5, 9], [[4, 6],[2, 0]]

आउटपुट

[3, -1]