Le problème est le suivant :

Étant donné un tableau d'entiers nums et une valeur entière, supprimez toutes les occurrences de val dans nums sur place . L'ordre des éléments peut être modifié. Renvoyez ensuite le nombre d'éléments en nombres qui ne sont pas égaux à val.

Considérez le nombre d'éléments en nombres qui ne sont pas égaux à val be k, pour être accepté, vous devez faire les choses suivantes :

• Modifiez le tableau nums de telle sorte que les k premiers éléments de nums contiennent les éléments qui ne sont pas égaux à val. Les éléments restants des nombres ne sont pas importants ainsi que la taille des nombres.
• Retour k.

Juge personnalisé :

Le juge testera votre solution avec le code suivant :

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 



Si toutes les assertions sont réussies, votre solution sera acceptée.

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




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




Voici comment je l'ai résolu :

Pour résoudre ce problème, j'ai utilisé deux stratégies principales :


Remplacement sur place : au lieu de créer un nouveau tableau pour stocker les éléments qui ne sont pas égaux à val, utilisez les mêmes numéros de tableau pour écraser les éléments qui doivent être supprimés.

Technique à deux pointeurs : un pointeur (i) parcourt chaque élément du tableau et un autre pointeur (k) garde une trace de la position où le prochain élément non val doit être placé.

• Tout d'abord, initialisez un pointeur k et définissez-le sur 0. Cela gardera une trace de la position où le prochain élément non-val doit être placé.

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

• Parcourir le tableau nums.
• Vérifiez si les numéros d'élément actuels[i] sont différents de val pour garder une trace de k.
• Si c'est le cas, déplacez l'élément nums[i] vers la k-ème position et incrémentez k de 1 pour mettre à jour la position du prochain élément non val.

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

• Renvoie k, qui est le nombre d'éléments différent de val.

return k

Voici la solution complétée :

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