समस्या का विवरण:

अक्षरों की एक श्रृंखला को देखते हुए, इसे निम्नलिखित एल्गोरिदम का उपयोग करके संपीड़ित करें:

• एक खाली स्ट्रिंग एस से शुरू करें।
• वर्णों में लगातार दोहराए जाने वाले वर्णों के प्रत्येक समूह के लिए:
  • यदि समूह की लंबाई 1 है, तो वर्ण को s में जोड़ें।
  • अन्यथा, समूह की लंबाई के बाद वर्ण जोड़ें।

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

इनपुट सरणी को संशोधित करने के बाद, सरणी की नई लंबाई लौटाएं।

आपको एक एल्गोरिदम लिखना होगा जो केवल निरंतर अतिरिक्त स्थान का उपयोग करता है।

उदाहरण 1:

• इनपुट: वर्ण = ["ए","ए","बी","बी","सी","सी","सी"]
• आउटपुट: रिटर्न 6, और इनपुट ऐरे के पहले 6 अक्षर होने चाहिए: ["ए","2","बी","2","सी","3"]
• स्पष्टीकरण: समूह "एए", "बीबी", और "सीसीसी" हैं। यह "a2b2c3" पर संपीड़ित होता है।

उदाहरण 2:

• इनपुट: वर्ण = ["ए"]
• आउटपुट: रिटर्न 1, और इनपुट ऐरे का पहला अक्षर होना चाहिए: ["ए"]
• स्पष्टीकरण: एकमात्र समूह "ए" है, जो एकल वर्ण होने के कारण असंपीड़ित रहता है।

उदाहरण 3:

• इनपुट: वर्ण = ["ए","बी","बी","बी","बी","बी","बी","बी","बी","बी","बी ","बी","बी"]
• आउटपुट: रिटर्न 4, और इनपुट ऐरे के पहले 4 अक्षर होने चाहिए: ["ए","बी","1","2"]
• स्पष्टीकरण: समूह "ए" और "बीबीबीबीबीबीबीबीबीबीबी" हैं। यह "ab12" तक संकुचित हो जाता है।

प्रतिबंध:

• 1
• chars[i] एक लोअरकेस अंग्रेजी अक्षर, अपरकेस अंग्रेजी अक्षर, अंक या प्रतीक है।

प्रारंभिक विचार प्रक्रिया:

इस समस्या को हल करने के लिए, हमें वर्तमान चरित्र और उसकी गिनती पर नज़र रखते हुए सरणी के माध्यम से पुनरावृत्त करने की आवश्यकता है। जब हमें कोई नया वर्ण मिलता है, तो हम वर्तमान वर्ण और उसकी संख्या (यदि 1 से अधिक हो) को सरणी में जोड़ देते हैं। हमें यह सुनिश्चित करने की आवश्यकता है कि हम अंतरिक्ष जटिलता की आवश्यकता को पूरा करने के लिए ऐसा करें।

मूल समाधान (क्रूर बल):

ब्रूट फोर्स समाधान में इनपुट सरणी के संपीड़ित संस्करण को संग्रहीत करने के लिए एक नई सरणी बनाना शामिल है। यह स्थान कुशल नहीं है लेकिन हमें इसमें शामिल चरणों को समझने में मदद करता है।

कोड:

function compressBruteForce(chars: string[]): number {
    const n = chars.length;
    let compressed: string[] = [];
    let i = 0;

    while (i  1) {
            compressed.push(...count.toString().split(''));
        }
    }

    for (let j = 0; j 




  
  
  समय जटिलता विश्लेषण:

• समय जटिलता: O(n), जहां n सरणी की लंबाई है। हम वर्णों को गिनने के लिए एक बार और परिणाम लिखने के लिए एक बार सरणी के माध्यम से दोहराते हैं।
• अंतरिक्ष जटिलता: O(n), क्योंकि हम संपीड़ित सरणी के लिए अतिरिक्त स्थान का उपयोग करते हैं।

सीमाएँ:

क्रूर बल समाधान स्थान कुशल नहीं है और केवल निरंतर अतिरिक्त स्थान का उपयोग करने की बाधा को पूरा नहीं करता है।

अनुकूलित समाधान:

अनुकूलित समाधान में संपीड़ित संस्करण को संग्रहीत करने के लिए इनपुट सरणी को संशोधित करना शामिल है। हम दो पॉइंटर्स का उपयोग करते हैं: एक इनपुट ऐरे को पढ़ने के लिए और दूसरा संपीड़ित आउटपुट लिखने के लिए।

कोड:

function compress(chars: string[]): number {
    let writeIndex = 0;
    let i = 0;

    while (i  1) {
            let countStr = count.toString();
            for (let j = 0; j 




  
  
  समय जटिलता विश्लेषण:

• समय जटिलता: O(n), जहां n सरणी की लंबाई है। हम वर्णों को गिनने के लिए एक बार और परिणाम लिखने के लिए एक बार सरणी के माध्यम से दोहराते हैं।
• अंतरिक्ष जटिलता: O(1), क्योंकि हम चरों के लिए केवल एक स्थिर मात्रा में अतिरिक्त स्थान का उपयोग करते हैं।

बुनियादी समाधान की तुलना में सुधार:

• अनुकूलित समाधान इनपुट सरणी को संशोधित करके अंतरिक्ष जटिलता को O(1) तक कम कर देता है।

किनारे के मामले और परीक्षण:

किनारे के मामले:

1. सरणी में केवल एक वर्ण है।
2. सरणी में लगातार दोहराए जाने वाले कोई वर्ण नहीं हैं।
3. सरणी में बड़ी संख्या में लगातार दोहराए जाने वाले वर्ण हैं।

परीक्षण मामले:

console.log(compressBruteForce(["a","a","b","b","c","c","c"])); // 6, ["a","2","b","2","c","3"]
console.log(compressBruteForce(["a"])); // 1, ["a"]
console.log(compressBruteForce(["a","b","b","b","b","b","b","b","b","b","b","b","b"])); // 4, ["a","b","1","2"]
console.log(compressBruteForce(["a","a","a","a","a","a","a","a","a","a"])); // 3, ["a","1","0"]
console.log(compressBruteForce(["a","b","c"])); // 3, ["a","b","c"]

console.log(compress(["a","a","b","b","c","c","c"])); // 6, ["a","2","b","2","c","3"]
console.log(compress(["a"])); // 1, ["a"]
console.log(compress(["a","b","b","b","b","b","b","b","b","b","b","b","b"])); // 4, ["a","b","1","2"]
console.log(compress(["a","a","a","a","a","a","a","a","a","a"])); // 3, ["a","1","0"]
console.log(compress(["a","b","c"])); // 3, ["a","b","c"]

सामान्य समस्या-समाधान रणनीतियाँ:

1. समस्या को समझें: आवश्यकताओं और बाधाओं को समझने के लिए समस्या विवरण को ध्यान से पढ़ें।
2. मुख्य परिचालनों को पहचानें: आवश्यक प्रमुख परिचालनों को निर्धारित करें, जैसे लगातार वर्णों की गिनती करना और जगह में सरणी को संशोधित करना।
3. दक्षता के लिए अनुकूलन: समय और स्थान की जटिलता को कम करने के लिए कुशल एल्गोरिदम और डेटा संरचनाओं का उपयोग करें।
4. पूरी तरह से परीक्षण करें: शुद्धता सुनिश्चित करने के लिए किनारे के मामलों सहित विभिन्न मामलों के साथ समाधान का परीक्षण करें।

समान समस्याओं की पहचान करना:

1. स्ट्रिंग हेरफेर:

   • समस्याएं जहां आपको विशिष्ट स्थितियों के आधार पर स्ट्रिंग को संशोधित करने की आवश्यकता होती है।
   • उदाहरण: एक स्ट्रिंग से डुप्लिकेट हटाना।

2. इन-प्लेस एल्गोरिदम:

   • ऐसी समस्याएं जहां संचालन को सीमित अतिरिक्त स्थान के साथ निष्पादित करने की आवश्यकता होती है।
   • उदाहरण: अतिरिक्त स्थान के बिना किसी सरणी से तत्वों को हटाना।

निष्कर्ष:

• एक चरित्र सरणी को संपीड़ित करने की समस्या को एक क्रूर बल दृष्टिकोण और एक अनुकूलित इन-प्लेस दृष्टिकोण दोनों का उपयोग करके कुशलतापूर्वक हल किया जा सकता है।
• समस्या को समझना और उसे प्रबंधनीय भागों में तोड़ना महत्वपूर्ण है।
• कुशल एल्गोरिदम का उपयोग यह सुनिश्चित करता है कि समाधान बड़े इनपुट के लिए इष्टतम है।
• विभिन्न किनारे के मामलों के साथ परीक्षण मजबूती सुनिश्चित करता है।
• समस्याओं में पैटर्न को पहचानने से अन्य चुनौतियों के लिए समान समाधान लागू करने में मदद मिल सकती है।

ऐसी समस्याओं और रणनीतियों का अभ्यास करके, आप अपने समस्या-समाधान कौशल में सुधार कर सकते हैं और विभिन्न कोडिंग चुनौतियों के लिए बेहतर ढंग से तैयार हो सकते हैं।