समस्या इस प्रकार है:

एक पूर्णांक सरणी संख्याओं और एक पूर्णांक वैल को देखते हुए, अंकों में वैल की सभी घटनाओं को हटा दें इन-प्लेस। तत्वों का क्रम बदला जा सकता है. फिर तत्वों की संख्या को संख्याओं में लौटाएं जो वैल के बराबर नहीं हैं।

संख्याओं में उन तत्वों की संख्या पर विचार करें जो वैल बी के के बराबर नहीं हैं, स्वीकृत होने के लिए, आपको निम्नलिखित कार्य करने होंगे:

• सरणी संख्याओं को ऐसे बदलें कि संख्याओं के पहले k तत्वों में वे तत्व शामिल हों जो वैल के बराबर नहीं हैं। अंकों के शेष तत्व और अंकों का आकार महत्वपूर्ण नहीं हैं।
• रिटर्न के.

कस्टम जज:

न्यायाधीश निम्नलिखित कोड के साथ आपके समाधान का परीक्षण करेंगे:

int[] nums = [...]; // Input array
int val = ...; // Value to remove
int[] expectedNums = [...]; // The expected answer with correct length.
                            // It is sorted with no values equaling val.

int k = removeElement(nums, val); // Calls your implementation

assert k == expectedNums.length;
sort(nums, 0, k); // Sort the first k elements of nums
for (int i = 0; i 



यदि सभी दावे पारित हो जाते हैं, तो आपका समाधान स्वीकार कर लिया जाएगा।

उदाहरण 1:



Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2,_,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 2.
It does not matter what you leave beyond the returned k (hence they are underscores).




उदाहरण 2:



Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,4,0,3,_,_,_]
Explanation: Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4.
Note that the five elements can be returned in any order.
It does not matter what you leave beyond the returned k (hence they are underscores).




मैंने इसे इस प्रकार हल किया:

इस समस्या को हल करने के लिए, मैंने दो मुख्य रणनीतियों का उपयोग किया:



इन-प्लेस रिप्लेसमेंट: उन तत्वों को संग्रहीत करने के लिए एक नई सरणी बनाने के बजाय जो वैल के बराबर नहीं हैं, उन तत्वों को अधिलेखित करने के लिए समान सरणी संख्याओं का उपयोग करें जिन्हें हटाने की आवश्यकता है।

दो-सूचक तकनीक: एक सूचक (i) सरणी में प्रत्येक तत्व के माध्यम से पुनरावृत्त होता है, और दूसरा सूचक (k) उस स्थिति का ट्रैक रखता है जहां अगला गैर-वैल तत्व रखा जाना चाहिए।

• सबसे पहले, एक पॉइंटर k प्रारंभ करें और इसे 0 पर सेट करें। यह उस स्थिति का ट्रैक रखेगा जहां अगला गैर-वैल तत्व रखा जाना चाहिए।

class Solution:
def removeElement(self, nums: List[int], val: int) -> int:       
    k = 0

• संख्या सरणी के माध्यम से पुनरावृति करें।
• जांचें कि क्या वर्तमान तत्व संख्याएं[i] k का ट्रैक रखने के लिए वैल से अलग है।
• यदि ऐसा है, तो तत्व संख्या[i] को k-वें स्थान पर ले जाएं, और अगले गैर-वैल तत्व के लिए स्थिति को अपडेट करने के लिए k को 1 से बढ़ाएं।

for i in range(len(nums)):
    if nums[i] != val:
        nums[k] = nums[i]
        k  = 1

• रिटर्न k, जो कि वैल के बराबर नहीं होने वाले तत्वों की संख्या है।

return k

यहां पूरा समाधान दिया गया है:

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        k = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[k] = nums[i]
                k  = 1
        return k