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

एक इनपुट स्ट्रिंग s देते हुए, शब्दों के क्रम को उलट दें। एक शब्द को गैर-अंतरिक्ष वर्णों के अनुक्रम के रूप में परिभाषित किया गया है। एस में शब्दों को कम से कम एक स्थान से अलग किया जाएगा। एक ही स्थान द्वारा संयोजित उल्टे क्रम में शब्दों की एक स्ट्रिंग लौटाएँ।

ध्यान दें कि s में दो शब्दों के बीच आगे या पीछे वाले स्थान या एकाधिक स्थान हो सकते हैं। लौटाई गई स्ट्रिंग में शब्दों को अलग करने के लिए केवल एक ही स्थान होना चाहिए। कोई अतिरिक्त स्थान शामिल न करें।

उदाहरण 1:

• इनपुट: s = "आसमान नीला है"
• आउटपुट: "नीला आकाश है"

उदाहरण 2:

• इनपुट: s = "हैलो वर्ल्ड"
• आउटपुट: "वर्ल्ड हैलो"
• स्पष्टीकरण: आपकी उलटी स्ट्रिंग में आगे या पीछे वाले स्थान नहीं होने चाहिए।

उदाहरण 3:

• इनपुट: s = "एक अच्छा उदाहरण"
• आउटपुट: "उदाहरण अच्छा है"
• स्पष्टीकरण: आपको दो शब्दों के बीच कई रिक्त स्थानों को उलटी हुई स्ट्रिंग में एक ही स्थान पर कम करना होगा।

प्रतिबंध:

• 1
• s में अंग्रेजी अक्षर (अपरकेस और लोअरकेस), अंक और रिक्त स्थान '' शामिल हैं।
• s में कम से कम एक शब्द है।

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

इस समस्या को हल करने के लिए, हमें यह करना होगा:

1. स्ट्रिंग को शब्दों में विभाजित करें।
2. शब्दों का क्रम उल्टा करें।
3. शब्दों को वापस एक साथ जोड़ें और प्रत्येक के बीच एक खाली स्थान रखें।

मूल समाधान:

कोड:

function reverseWordsBruteForce(s: string): string {
    // Split the string by spaces and filter out empty strings
    let words = s.trim().split(/\s /);

    // Reverse the array of words
    words.reverse();

    // Join the words with a single space
    return words.join(' ');
}

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

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

सीमाएँ:

बाधाओं को देखते हुए यह समाधान कुशल है। हालाँकि, यह शब्दों की श्रृंखला के लिए अतिरिक्त स्थान का उपयोग करता है।

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

यदि स्ट्रिंग डेटा प्रकार परिवर्तनशील है और हमें इसे O(1) अतिरिक्त स्थान के साथ हल करने की आवश्यकता है, तो हम मूल स्ट्रिंग के भीतर शब्दों को उलटने के लिए दो-पॉइंटर तकनीक का उपयोग कर सकते हैं।

कोड:

function reverseWordsOptimized(s: string): string {
    // Trim the string and convert it to an array of characters
    let chars = s.trim().split('');

    // Helper function to reverse a portion of the array in place
    function reverse(arr: string[], left: number, right: number) {
        while (left 




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

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

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

• अनुकूलित समाधान वर्णों की श्रृंखला पर इन-प्लेस संचालन करके अंतरिक्ष जटिलता को कम करता है।

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

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

1. स्ट्रिंग में आगे और पीछे के स्थान हैं।
2. स्ट्रिंग में शब्दों के बीच कई रिक्त स्थान होते हैं।
3. स्ट्रिंग में केवल एक शब्द है।
4. स्ट्रिंग की लंबाई न्यूनतम या अधिकतम सीमा पर है।

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

console.log(reverseWordsBruteForce("the sky is blue")); // "blue is sky the"
console.log(reverseWordsBruteForce("  hello world  ")); // "world hello"
console.log(reverseWordsBruteForce("a good   example")); // "example good a"
console.log(reverseWordsBruteForce("singleWord")); // "singleWord"
console.log(reverseWordsBruteForce("   ")); // ""

console.log(reverseWordsOptimized("the sky is blue")); // "blue is sky the"
console.log(reverseWordsOptimized("  hello world  ")); // "world hello"
console.log(reverseWordsOptimized("a good   example")); // "example good a"
console.log(reverseWordsOptimized("singleWord")); // "singleWord"
console.log(reverseWordsOptimized("   ")); // ""

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

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

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

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

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

2. दो-सूचक तकनीक:

   • ऐसी समस्याएं जहां दो पॉइंटर्स का उपयोग करने से समाधान को अनुकूलित करने में मदद मिल सकती है।
   • उदाहरण: क्रमबद्ध सरणी से डुप्लिकेट हटाना।

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

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

निष्कर्ष:

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

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