जावास्क्रिप्ट में सर्कुलर ऐरे में अगला ग्रेटर एलिमेंट

गोलाकार सरणी

एक सरणी जिसमें अंतिम तत्व का अगला तत्व सरणी का पहला तत्व होता है उसे अक्सर वृत्ताकार कहा जाता है।

जाहिर है, इस तरह डेटा को स्टोर करने के लिए ऐसा कोई तंत्र मौजूद नहीं है, डेटा अभी भी निरंतर मेमोरी ब्लॉक में संग्रहीत किया जाएगा और सर्कुलर एरे वास्तविकता की तुलना में एक विचार की तरह अधिक हैं।

समस्या

हमें एक जावास्क्रिप्ट फ़ंक्शन लिखने की आवश्यकता है जो पहले और एकमात्र तर्क के रूप में इंटीजर, एआर की गोलाकार सरणी लेता है।

फ़ंक्शन को तब एक सरणी का निर्माण और वापसी करनी चाहिए जिसमें मूल सरणी के प्रत्येक संबंधित तत्व के लिए अगला बड़ा तत्व होता है। किसी संख्या की अगली बड़ी संख्या, मान लीजिए संख्या, सरणी में इसके ट्रैवर्सिंग-ऑर्डर (हमारे मामले में सही) की पहली बड़ी संख्या है, जिसका अर्थ है कि हम इसकी अगली बड़ी संख्या को खोजने के लिए गोलाकार खोज कर सकते हैं। अगर वह मौजूद नहीं है, तो हमें इस नंबर के लिए -1 पर विचार करना चाहिए।

उदाहरण के लिए, यदि फ़ंक्शन का इनपुट है -

const arr = [7, 8, 7];

तब आउटपुट होना चाहिए -

const output = [8, -1, 8];

आउटपुट स्पष्टीकरण

सरणी में दोनों 7s के आगे 8 है और चूंकि सरणी गोलाकार है लेकिन 8 के लिए, कोई बड़ा तत्व नहीं है इसलिए हम इसके लिए -1 डालते हैं।

उदाहरण

इसके लिए कोड होगा -

const arr = [7, 8, 7];
const nextGreaterElement = (arr = []) => {
   const res = [];
   const stack = [];
   if (!arr || arr.length < 1){
      return res;
   };
   for (let i = 0; i < arr.length; i++) {
      while (stack.length > 0 && arr[stack[stack.length - 1]] < arr[i]) {
         const small = stack.pop();
         res[small] = arr[i];
      };
      stack.push(i);
   }
   for (let i = 0; i < arr.length; i++) {
      while (stack.length > 0 && arr[stack[stack.length - 1]] < arr[i]) {
         const small = stack.pop();
         res[small] = arr[i];
      };
   }
   const rem = stack.length;
   for (let i = 0; i < rem; i++) {
      res[stack.pop()] = -1;
      }
      return res;
   };
console.log(nextGreaterElement(arr));

कोड स्पष्टीकरण:

सरणी पर पुनरावृति करते समय यदि हमें कोई ऐसा तत्व मिलता है जो स्टैक में एक से बड़ा होता है, तो हम res [छोटा] को वर्तमान में पाए गए बड़े तत्व पर सेट करते हैं।

अब, हम फिर से गिरफ्तारी की शुरुआत से शुरू करते हैं और उन तत्वों से निपटते हैं जिनके लिए हमें पिछले लूप में अगला बड़ा तत्व नहीं मिला। अंत में, अभी भी कुछ ऐसे तत्व होंगे जिनके लिए कोई अगला बड़ा तत्व नहीं था।

आउटपुट

और कंसोल में आउटपुट होगा -

[8, -1, 8]