Das Problem ist wie folgt:

Entfernen Sie bei einem gegebenen Integer-Array nums und einem Integer-Wert alle Vorkommen von val in nums an Ort und Stelle. Die Reihenfolge der Elemente kann geändert werden. Geben Sie dann die Anzahl der Elemente in Zahlen zurück, die nicht gleich val sind.

Berücksichtigen Sie die Anzahl der Elemente in Zahlen, die nicht gleich dem Wert k sind. Um akzeptiert zu werden, müssen Sie die folgenden Dinge tun:

• Ändern Sie das Array nums so, dass die ersten k Elemente von nums die Elemente enthalten, die nicht gleich val sind. Die übrigen Elemente von Nums sind nicht so wichtig wie die Größe von Nums.
• K zurückgeben.

Benutzerdefinierter Richter:

Der Richter testet Ihre Lösung mit dem folgenden Code:

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 



Wenn alle Behauptungen bestehen, wird Ihre Lösung akzeptiert.

Beispiel 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).




Beispiel 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).




So habe ich es gelöst:

Um dieses Problem zu lösen, habe ich zwei Hauptstrategien verwendet:



Direkter Ersatz: Anstatt ein neues Array zum Speichern der Elemente zu erstellen, die nicht gleich val sind, verwenden Sie dieselben Array-Nummern, um die Elemente zu überschreiben, die entfernt werden müssen.

Zwei-Zeiger-Technik: Ein Zeiger (i) durchläuft jedes Element im Array, und ein anderer Zeiger (k) verfolgt die Position, an der das nächste Nicht-Val-Element platziert werden soll.

• Initialisieren Sie zunächst einen Zeiger k und setzen Sie ihn auf 0. Dadurch wird die Position verfolgt, an der das nächste Nicht-Val-Element platziert werden soll.

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

• Durch das Nums-Array iterieren.
• Überprüfen Sie, ob sich die aktuellen Elementnummern[i] von val unterscheiden, um den Überblick über k zu behalten.
• Wenn ja, verschieben Sie Element nums[i] an die k-te Position und erhöhen Sie k um 1, um die Position für das nächste Nicht-Val-Element zu aktualisieren.

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

• Gibt k zurück, was die Anzahl der Elemente ungleich val ist.

return k

Hier ist die fertige Lösung:

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