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

एक पूर्णांक सरणी संख्याओं को देखते हुए, एक सरणी उत्तर लौटाएं जैसे कि उत्तर[i] संख्याओं को छोड़कर संख्याओं के सभी तत्वों के उत्पाद के बराबर हो[i]।

अंकों के किसी भी उपसर्ग या प्रत्यय का उत्पाद 32-बिट पूर्णांक में फिट होने की गारंटी है।

आपको एक एल्गोरिदम लिखना होगा जो ओ(एन) समय में और डिवीजन ऑपरेशन का उपयोग किए बिना चलता है।

उदाहरण 1:

• इनपुट: अंक = [1,2,3,4]
• आउटपुट: [24,12,8,6]

उदाहरण 2:

• इनपुट: अंक = [-1,1,0,-3,3]
• आउटपुट: [0,0,9,0,0]

प्रतिबंध:

• 2
• -30
• अंकों के किसी भी उपसर्ग या प्रत्यय का उत्पाद 32-बिट पूर्णांक में फिट होने की गारंटी है।

पालन ​​करें:

क्या आप O(1) अतिरिक्त स्थान जटिलता में समस्या का समाधान कर सकते हैं? (आउटपुट सरणी को अंतरिक्ष जटिलता विश्लेषण के लिए अतिरिक्त स्थान के रूप में नहीं गिना जाता है।)

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

इस समस्या को हल करने के लिए, हमें विभाजन ऑपरेशन का उपयोग किए बिना वर्तमान तत्व को छोड़कर सभी तत्वों के उत्पाद की गणना करने की आवश्यकता है। यह सरणी के ऊपर दो पासों का उपयोग करके किया जा सकता है:

1. प्रत्येक तत्व के लिए उपसर्ग उत्पादों की गणना करें।
2. प्रत्येक तत्व के लिए प्रत्यय उत्पादों की गणना करें और उपसर्ग उत्पादों के साथ गुणा करें।

मूल समाधान:

हम उपसर्ग और प्रत्यय उत्पादों को संग्रहीत करने के लिए दो सरणियों का उपयोग कर सकते हैं, फिर अंतिम परिणाम प्राप्त करने के लिए उन्हें गुणा कर सकते हैं।

कोड:

function productExceptSelf(nums: number[]): number[] {
    const n = nums.length;
    const prefixProducts = new Array(n).fill(1);
    const suffixProducts = new Array(n).fill(1);
    const result = new Array(n).fill(1);

    // Compute prefix products
    for (let i = 1; i = 0; i--) {
        suffixProducts[i] = suffixProducts[i   1] * nums[i   1];
    }

    // Compute the result by multiplying prefix and suffix products
    for (let i = 0; i 




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

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

सीमाएँ:

मूल समाधान अच्छी तरह से काम करता है लेकिन उपसर्ग और प्रत्यय उत्पादों को संग्रहीत करने के लिए अतिरिक्त स्थान का उपयोग करता है।

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

हम पहले उपसर्ग उत्पादों को संग्रहीत करने के लिए आउटपुट सरणी का उपयोग करके ओ(1) अतिरिक्त स्थान का उपयोग करने के लिए समाधान को अनुकूलित कर सकते हैं और फिर प्रत्यय उत्पादों को शामिल करने के लिए इसे संशोधित कर सकते हैं।

कोड:

function productExceptSelfOptimized(nums: number[]): number[] {
    const n = nums.length;
    const result = new Array(n).fill(1);

    // Compute prefix products in the result array
    for (let i = 1; i = 0; i--) {
        result[i] = result[i] * suffixProduct;
        suffixProduct *= nums[i];
    }

    return result;
}

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

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

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

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

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

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

1. सरणी में शून्य हैं।
2. सरणी में ऋणात्मक संख्याएँ हैं।
3. सरणी की लंबाई न्यूनतम (2) या अधिकतम (10^5) सीमा है।

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

console.log(productExceptSelf([1,2,3,4])); // [24,12,8,6]
console.log(productExceptSelf([-1,1,0,-3,3])); // [0,0,9,0,0]
console.log(productExceptSelf([2,2,2,2])); // [8,8,8,8]
console.log(productExceptSelf([0,0])); // [0,0]
console.log(productExceptSelf([5])); // This should not be a valid input as the minimum length is 2
console.log(productExceptSelf([1,2])); // [2, 1]

console.log(productExceptSelfOptimized([1,2,3,4])); // [24,12,8,6]
console.log(productExceptSelfOptimized([-1,1,0,-3,3])); // [0,0,9,0,0]
console.log(productExceptSelfOptimized([2,2,2,2])); // [8,8,8,8]
console.log(productExceptSelfOptimized([0,0])); // [0,0]
console.log(productExceptSelfOptimized([5])); // This should not be a valid input as the minimum length is 2
console.log(productExceptSelfOptimized([1,2])); // [2, 1]

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

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

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

1. उपसर्ग योग सारणी:

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

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

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

3. सरणी हेरफेर:

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

निष्कर्ष:

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

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