JavaScript में डुप्लिकेट वर्ण घटनाओं को एक तक सीमित करना

समस्या

हमें एक JavaScript फ़ंक्शन लिखना है जो एक स्ट्रिंग str को एकमात्र आर्गुमेंट के रूप में लेता है।

फ़ंक्शन को इनपुट स्ट्रिंग के आधार पर एक नई स्ट्रिंग तैयार करनी चाहिए जिसमें प्रत्येक वर्ण की केवल एक उपस्थिति रखी जाए और रखा गया वर्ण वही हो जो परिणाम स्ट्रिंग को शब्दकोशीय रूप से सबसे छोटा बनाता है।

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

const str = 'cbacdcbc';

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

const output = 'acdb';

आउटपुट व्याख्या:

ध्यान दें कि हम स्ट्रिंग से 'c' की किसी भी घटना को हटा सकते थे लेकिन हमने सबसे पहले वाली को हटाया, जो स्ट्रिंग को शब्दकोशीय रूप से सबसे छोटा बनाती है और 'a' और 'b' के मामले में भी ऐसा ही है।

उदाहरण

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

const str = 'cbacdcbc'; 
const removeDuplicates = (str = '') => { 
  if (str.length <= 1) { 
    return str; 
  }; 
  let flag; 
  let string = ""; 
  let legend = new Array(26).fill(-1); 
  let last = "z"; 
  let ind = 0; 
  for (let i = str.length - 1; i > -1; i--) { 
    const element = str[i]; 
    if (legend[element.charCodeAt() - 97] < 0) { 
      legend[element.charCodeAt() - 97] = i; 
      last = element; 
      ind = i; 
      string += element; 
    } else { 
      if (last >= element) { 
        last = element; 
        ind = i; 
      } 
    } 
  } 
  let finalStr = last; 
  while (string.length > finalStr.length) { 
    legend.fill(-1); 
    for (let i = str.length - 1; i > ind; i--) { 
      const element = str[i]; 
      if (finalStr.indexOf(element) < 0) { 
        if (legend[element.charCodeAt() - 97] < 0) { 
          legend[element.charCodeAt() - 97] = i; 
          last = element; 
          flag = i; 
        } else { 
          if (last >= element) { 
            last = element; 
            flag = i; 
          } 
        } 
      } 
    } 
    ind = flag; 
    finalStr += last; 
  } 
  return finalStr; 
}; 
console.log(removeDuplicates(str));

कोड व्याख्या:

यहां विचार है -

पहली बार, हम पूरी स्ट्रिंग के माध्यम से लूप करते हैं ताकि यह जांच सकें कि कौन से अक्षर उपयोग किए गए हैं, और सबसे छोटा शुरुआती अक्षर सबस्ट्रिंग ढूंढते हैं जिसमें सभी वर्ण हों।

यह समझना आसान है अगर हम लूप को दाएं से बाएं शुरू करते हैं और सबस्ट्रिंग की शुरुआती स्थिति और शुरुआती न्यूनतम अक्षर को याद रखते हैं।

फिर हम सबस्ट्रिंग (शुरुआती न्यूनतम अक्षर के बिना) पर लूप करना शुरू करते हैं, फिर भी दाएं से बाएं, लेकिन इस बार हमें उन अक्षरों को अनदेखा करना होगा जो हमने पहले ही संग्रहीत किए हैं।

आउटपुट

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

acdb